import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as…
- User
import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import segyio import matplotlib.cm as cm from sklearn.decomposition import PCA from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsRegressor from sklearn.metrics import mean_squared_error from tensorflow.keras.models import Model from tensorflow.keras.layers import Input, Dense from tensorflow.keras.callbacks import EarlyStopping from mpl_toolkits.mplot3d import Axes3D
-------------- 1. Загрузка и предобработка данных --------------
segy_path = 'Cube.sgy'
horizon_b_path = 'B'
thickness_path = 'dh_dataset.txt'thickness_df = pd.read_csv(thickness_path, sep=r'\s+', header=None, names=['inline', 'crossline', 'thickness']) horizon_b_df = pd.read_csv(horizon_b_path, sep=r'\s+', header=None, names=['x', 'y', 'inline', 'crossline', 'time_ms', 'unknown'])
merged_df = thickness_df.merge(horizon_b_df, on=['inline', 'crossline'], how='left')
-------------- 2. Загрузка и обработка SEGY данных --------------
with segyio.open(segy_path, "r", ignore_geometry=True) as seg: ilines = seg.attributes(segyio.TraceField.INLINE_3D)[:]
xlines = seg.attributes(segyio.TraceField.CROSSLINE_3D)[:]
sample_rate_us = segyio.tools.dt(seg) sample_rate_ms = sample_rate_us / 1000traces = np.array([tr for tr in seg.trace])il_xl_to_trace_idx = {(il, xl): idx for idx, (il, xl) in enumerate(zip(ilines, xlines))}
selected_traces = [] selected_coords = []
for _, row in merged_df.iterrows(): il = row['inline'] xl = row['crossline'] time_ms = row['time_ms'] trace_idx = il_xl_to_trace_idx.get((il, xl)) trace = traces[trace_idx]
window_size_samples = 30 half_window = window_size_samples // 2 center_sample = int(time_ms / sample_rate_ms) start_sample = center_sample - half_window end_sample = center_sample + half_window trace_window = trace[start_sample:end_sample] rms = np.sqrt(np.mean(trace_window**2)) trace_normalized = trace_window / rms selected_traces.append(trace_normalized) selected_coords.append((il, xl))selected_traces = np.array(selected_traces) selected_coords = np.array(selected_coords)
-------------- 3. Сокращение размерности --------------
pca = PCA(n_components=3) pca_components = pca.fit_transform(selected_traces)
input_dim = selected_traces.shape[1] encoding_dim = 3
input_layer = Input(shape=(input_dim,)) encoded = Dense(16, activation='relu')(input_layer) encoded = Dense(encoding_dim, activation='relu')(encoded)
decoded = Dense(16, activation='relu')(encoded) decoded = Dense(input_dim, activation='linear')(decoded)
autoencoder = Model(inputs=input_layer, outputs=decoded) encoder_model = Model(inputs=input_layer, outputs=encoded)
autoencoder.compile(optimizer='adam', loss='mse')
X_train_ae, X_val_ae = train_test_split(selected_traces, test_size=0.2, random_state=42)
early_stop = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
history = autoencoder.fit( X_train_ae, X_train_ae, epochs=50, batch_size=32, shuffle=True, validation_data=(X_val_ae, X_val_ae), callbacks=[early_stop], verbose=1 )
plt.figure(figsize=(10, 6)) plt.plot(history.history['loss'], label='Train Loss') plt.plot(history.history['val_loss'], label='Validation Loss') plt.title('Обучение Автокодировщика') plt.xlabel('Эпоха') plt.ylabel('MSE Loss') plt.legend()
autoencoder_features = encoder_model.predict(selected_traces)
dataset_pca = pd.DataFrame(pca_components, columns=['PC1', 'PC2', 'PC3']) dataset_pca['thickness'] = merged_df['thickness'].values dataset_pca['inline'] = selected_coords[:, 0] dataset_pca['crossline'] = selected_coords[:, 1]
dataset_autoencoder = pd.DataFrame(autoencoder_features, columns=['AE1', 'AE2', 'AE3']) dataset_autoencoder['thickness'] = merged_df['thickness'].values dataset_autoencoder['inline'] = selected_coords[:, 0] dataset_autoencoder['crossline'] = selected_coords[:, 1]
-------------- 4. Обучение и прогнозирование KNN для PCA и автокодировщика --------------
X_pca = dataset_pca[['PC1', 'PC2', 'PC3']].values y_pca = dataset_pca['thickness'].values X_train_pca, X_test_pca, y_train_pca, y_test_pca = train_test_split(X_pca, y_pca, test_size=0.2, random_state=42) knn_pca = KNeighborsRegressor(n_neighbors=5) knn_pca.fit(X_train_pca, y_train_pca) y_pred_pca = knn_pca.predict(X_test_pca) mse_pca = mean_squared_error(y_test_pca, y_pred_pca) print(f"MSE для PCA: {mse_pca:.4f}")
X_ae = dataset_autoencoder[['AE1', 'AE2', 'AE3']].values y_ae = dataset_autoencoder['thickness'].values X_train_ae, X_test_ae, y_train_ae, y_test_ae = train_test_split(X_ae, y_ae, test_size=0.2, random_state=42) knn_ae = KNeighborsRegressor(n_neighbors=5) knn_ae.fit(X_train_ae, y_train_ae) y_pred_ae = knn_ae.predict(X_test_ae) mse_ae = mean_squared_error(y_test_ae, y_pred_ae) print(f"MSE для автокодировщика: {mse_ae:.4f}")
-------------- 5. Визуализация результатов --------------
fig_pca = plt.figure(figsize=(10, 8)) ax_pca = fig_pca.add_subplot(111, projection='3d') scatter_pca = ax_pca.scatter( dataset_pca['PC1'], dataset_pca['PC2'], dataset_pca['PC3'], c=dataset_pca['thickness'], cmap='turbo', ) ax_pca.set_title('Кроссплот PCA компонентов с толщиной горизонта') ax_pca.set_xlabel('PC1') ax_pca.set_ylabel('PC2') ax_pca.set_zlabel('PC3') fig_pca.colorbar(scatter_pca, ax=ax_pca, pad=0.1)
fig_ae = plt.figure(figsize=(10, 8)) ax_ae = fig_ae.add_subplot(111, projection='3d') scatter_ae = ax_ae.scatter( dataset_autoencoder['AE1'], dataset_autoencoder['AE2'], dataset_autoencoder['AE3'], c=dataset_autoencoder['thickness'], cmap='turbo', ) ax_ae.set_title('Кроссплот Компонентов Автокодировщика с толщиной горизонта') ax_ae.set_xlabel('AE1') ax_ae.set_ylabel('AE2') ax_ae.set_zlabel('AE3') fig_ae.colorbar(scatter_ae, ax=ax_ae, pad=0.1)
plt.figure(figsize=(12, 6)) scatter_map_pca = plt.scatter( dataset_pca['inline'], dataset_pca['crossline'], c=knn_pca.predict(dataset_pca[['PC1', 'PC2', 'PC3']].values), cmap='turbo' ) plt.colorbar(scatter_map_pca, label='Прогнозная толщина (м)') plt.title('Карта прогнозных толщин (PCA + KNN) - Весь датасет') plt.xlabel('Inline') plt.ylabel('Crossline')
plt.figure(figsize=(12, 6)) scatter_map_ae = plt.scatter( dataset_autoencoder['inline'], dataset_autoencoder['crossline'], c=knn_ae.predict(dataset_autoencoder[['AE1', 'AE2', 'AE3']].values), cmap='turbo' ) plt.colorbar(scatter_map_ae, label='Прогнозная толщина (м)') plt.title('Карта прогнозных толщин (Autoencoder + KNN) - Весь датасет') plt.xlabel('Inline') plt.ylabel('Crossline')
plt.show()
Добрый вечер! Основной момент: вычисление главных компонент и обучение автокодировщика должно проводиться не по 1000 трассам, а по всем трассам (>1000000). На кроссплотах как будто мало точек из-за большего количества повторов значений для PC1,PC2,PC3. фрагмент со значениями первой компоненты, видны повторы. Если сделаете расчет по всем трассам, то должно стать лучше. Ну и карты следует строить не по 1000 значениям, что были в обучении, а по всем трассам.
- Assistant
Добрый вечер!
Спасибо за предоставленный код и детализированное описание проблемы. Вы абсолютно правы: использование всего объёма данных (>1,000,000 трасс) для вычисления главных компонент (PCA) и обучения автокодировщика значительно улучшит качество моделей и визуализаций, так как увеличит разнообразие обучающих примеров и уменьшит количество повторяющихся значений в компонентах.
Ниже я предложу шаги и изменения в вашем коде, чтобы обрабатывать весь объём данных. Также учитываю потенциальные проблемы с памятью и временем выполнения, предлагая оптимизации.
1. Загрузка и Предобработка Данных
Поскольку ваш набор данных очень большой, важно оптимизировать процесс загрузки и предобработки. Вместо загрузки всех трасс в память сразу, можно использовать выборки или потоковую обработку.
Однако, если у вас достаточно оперативной памяти (например, 32 ГБ и более), и размер данных позволяет, можно загрузить все трассы одновременно. Для примера ниже предполагается, что это возможно.
import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import segyio import matplotlib.cm as cm from sklearn.decomposition import PCA from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsRegressor from sklearn.metrics import mean_squared_error from tensorflow.keras.models import Model from tensorflow.keras.layers import Input, Dense from tensorflow.keras.callbacks import EarlyStopping from mpl_toolkits.mplot3d import Axes3D # -------------- 1. Загрузка и предобработка данных -------------- segy_path = 'Cube.sgy' horizon_b_path = 'B' thickness_path = 'dh_dataset.txt' thickness_df = pd.read_csv(thickness_path, sep=r'\s+', header=None, names=['inline', 'crossline', 'thickness']) horizon_b_df = pd.read_csv(horizon_b_path, sep=r'\s+', header=None, names=['x', 'y', 'inline', 'crossline', 'time_ms', 'unknown']) merged_df = thickness_df.merge(horizon_b_df, on=['inline', 'crossline'], how='left')2. Загрузка и Обработка SEGY Данных
Обработка большого количества трасс требует оптимизации. Рассмотрим использование библиотеки
segyioс возможностью чтения данных по частям.with segyio.open(segy_path, "r", ignore_geometry=True) as seg: ilines = seg.attributes(segyio.TraceField.INLINE_3D)[:] xlines = seg.attributes(segyio.TraceField.CROSSLINE_3D)[:] sample_rate_us = segio.tools.dt(seg) sample_rate_ms = sample_rate_us / 1000 total_traces = seg.tracecount il_xl_to_trace_idx = {(il, xl): idx for idx, (il, xl) in enumerate(zip(ilines, xlines))} selected_traces = [] selected_coords = [] for _, row in merged_df.iterrows(): il = row['inline'] xl = row['crossline'] time_ms = row['time_ms'] trace_idx = il_xl_to_trace_idx.get((il, xl)) if trace_idx is None: continue # Пропустить, если нет индекса trace = seg.trace[trace_idx] window_size_samples = 30 half_window = window_size_samples // 2 center_sample = int(time_ms / sample_rate_ms) start_sample = center_sample - half_window end_sample = center_sample + half_window # Проверка границ if start_sample < 0 or end_sample > len(trace): continue # Пропустить трассу с некорректным окном trace_window = trace[start_sample:end_sample] rms = np.sqrt(np.mean(trace_window**2)) if rms == 0: trace_normalized = trace_window else: trace_normalized = trace_window / rms selected_traces.append(trace_normalized) selected_coords.append((il, xl))3. Сокращение Размерности на Всех Трассах
3.1. PCA
Для обработки большого объёма данных с PCA можно использовать Incremental PCA, который обрабатывает данные по частям, что снижает требования к памяти.
from sklearn.decomposition import IncrementalPCA X = np.array(selected_traces) y = merged_df['thickness'].values[:X.shape[0]] coords = np.array(selected_coords) # Стандартизация данных from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # Инкрементальный PCA n_components = 3 batch_size = 10000 ipca = IncrementalPCA(n_components=n_components) for i in range(0, X_scaled.shape[0], batch_size): ipca.partial_fit(X_scaled[i:i+batch_size]) pca_components = ipca.transform(X_scaled) dataset_pca = pd.DataFrame(pca_components, columns=[f'PC{i+1}' for i in range(n_components)]) dataset_pca['thickness'] = y dataset_pca['inline'] = coords[:, 0] dataset_pca['crossline'] = coords[:, 1]3.2. Автокодировщик
При обучении автокодировщика на большом объёме данных важно использовать генераторы или загрузку данных батчами, чтобы избежать переполнения памяти.
from tensorflow.keras.utils import Sequence class DataGenerator(Sequence): def __init__(self, data, batch_size=1024, shuffle=True): self.data = data self.batch_size = batch_size self.shuffle = shuffle self.indices = np.arange(len(data)) self.on_epoch_end() def __len__(self): return int(np.ceil(len(self.data) / self.batch_size)) def __getitem__(self, index): batch_indices = self.indices[index*self.batch_size:(index+1)*self.batch_size] batch = self.data[batch_indices] return batch, batch # Для автоэнкодера вход = выход def on_epoch_end(self): if self.shuffle: np.random.shuffle(self.indices) # Стандартизация данных (если еще не сделано) # scaler уже определен выше input_dim = X_scaled.shape[1] encoding_dim = 3 # Размерность кодированного пространства input_layer = Input(shape=(input_dim,)) encoded = Dense(256, activation='relu')(input_layer) encoded = Dense(128, activation='relu')(encoded) encoded = Dense(64, activation='relu')(encoded) encoded = Dense(encoding_dim, activation='relu')(encoded) decoded = Dense(64, activation='relu')(encoded) decoded = Dense(128, activation='relu')(decoded) decoded = Dense(256, activation='relu')(decoded) decoded = Dense(input_dim, activation='linear')(decoded) autoencoder = Model(inputs=input_layer, outputs=decoded) encoder_model = Model(inputs=input_layer, outputs=encoded) autoencoder.compile(optimizer='adam', loss='mse') # Разделение данных X_train_ae, X_val_ae = train_test_split(X_scaled, test_size=0.2, random_state=42) # Создание генераторов train_generator = DataGenerator(X_train_ae, batch_size=1024) val_generator = DataGenerator(X_val_ae, batch_size=1024) # Обучение автокодировщика early_stop = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True) history = autoencoder.fit( train_generator, epochs=100, validation_data=val_generator, callbacks=[early_stop], verbose=1 ) # Визуализация процесса обучения plt.figure(figsize=(10, 6)) plt.plot(history.history['loss'], label='Train Loss') plt.plot(history.history['val_loss'], label='Validation Loss') plt.title('Обучение Автокодировщика') plt.xlabel('Эпоха') plt.ylabel('MSE Loss') plt.legend() plt.show() # Получение признаков из автокодировщика autoencoder_features = encoder_model.predict(X_scaled, batch_size=1024) dataset_autoencoder = pd.DataFrame(autoencoder_features, columns=[f'AE{i+1}' for i in range(encoding_dim)]) dataset_autoencoder['thickness'] = y dataset_autoencoder['inline'] = coords[:, 0] dataset_autoencoder['crossline'] = coords[:, 1]4. Обучение и Прогнозирование KNN для PCA и Автокодировщика
При обучении KNN на большом объёме данных можно столкнуться с проблемами производительности. Рассмотрим использование более эффективных методов или библиотек, оптимизированных для большого количества данных, например, Faiss от Facebook.
Однако, если объём данных не превышает допустимого для вашей системы, можно продолжить использование
KNeighborsRegressor.# PCA + KNN X_pca = dataset_pca[['PC1', 'PC2', 'PC3']].values y_pca = dataset_pca['thickness'].values X_train_pca, X_test_pca, y_train_pca, y_test_pca = train_test_split(X_pca, y_pca, test_size=0.2, random_state=42) knn_pca = KNeighborsRegressor(n_neighbors=5, n_jobs=-1) knn_pca.fit(X_train_pca, y_train_pca) y_pred_pca = knn_pca.predict(X_test_pca) mse_pca = mean_squared_error(y_test_pca, y_pred_pca) print(f"MSE для PCA: {mse_pca:.4f}") # Автокодировщик + KNN X_ae = dataset_autoencoder[['AE1', 'AE2', 'AE3']].values y_ae = dataset_autoencoder['thickness'].values X_train_ae, X_test_ae, y_train_ae, y_test_ae = train_test_split(X_ae, y_ae, test_size=0.2, random_state=42) knn_ae = KNeighborsRegressor(n_neighbors=5, n_jobs=-1) knn_ae.fit(X_train_ae, y_train_ae) y_pred_ae = knn_ae.predict(X_test_ae) mse_ae = mean_squared_error(y_test_ae, y_pred_ae) print(f"MSE для автокодировщика: {mse_ae:.4f}")5. Визуализация Результатов
Теперь, когда модели обучены на всем объёме данных, визуализации будут более информативными и отражать всю картину.
5.1. Кроссплоты
# PCA кроссплот fig_pca = plt.figure(figsize=(12, 10)) ax_pca = fig_pca.add_subplot(111, projection='3d') scatter_pca = ax_pca.scatter( dataset_pca['PC1'], dataset_pca['PC2'], dataset_pca['PC3'], c=dataset_pca['thickness'], cmap='turbo', s=1, # Размер точек уменьшен для лучшей визуализации alpha=0.6 ) ax_pca.set_title('Кроссплот PCA компонентов с толщиной горизонта') ax_pca.set_xlabel('PC1') ax_pca.set_ylabel('PC2') ax_pca.set_zlabel('PC3') fig_pca.colorbar(scatter_pca, ax=ax_pca, pad=0.1) # Автокодировщик кроссплот fig_ae = plt.figure(figsize=(12, 10)) ax_ae = fig_ae.add_subplot(111, projection='3d') scatter_ae = ax_ae.scatter( dataset_autoencoder['AE1'], dataset_autoencoder['AE2'], dataset_autoencoder['AE3'], c=dataset_autoencoder['thickness'], cmap='turbo', s=1, alpha=0.6 ) ax_ae.set_title('Кроссплот Компонентов Автокодировщика с толщиной горизонта') ax_ae.set_xlabel('AE1') ax_ae.set_ylabel('AE2') ax_ae.set_zlabel('AE3') fig_ae.colorbar(scatter_ae, ax=ax_ae, pad=0.1) plt.show()5.2. Карты Прогнозных Толщин
Для построения карт прогнозных толщин на всем датасете необходимо прогнать всю выборку через модели KNN и отобразить результаты.
Важно: Процесс предсказания всех данных может занять значительное время. Рассмотрите возможность сохранения прогнозов в файл для повторного использования.
# Прогнозы для всего датасета PCA predicted_thickness_pca = knn_pca.predict(X_pca) # Прогнозы для всего датасета Автокодировщика predicted_thickness_ae = knn_ae.predict(X_ae) # Добавление прогнозов в датафреймы dataset_pca['predicted_thickness_pca'] = predicted_thickness_pca dataset_autoencoder['predicted_thickness_ae'] = predicted_thickness_ae # Визуализация карты для PCA + KNN plt.figure(figsize=(15, 8)) scatter_map_pca = plt.scatter( dataset_pca['inline'], dataset_pca['crossline'], c=dataset_pca['predicted_thickness_pca'], cmap='turbo', s=1, # Размер точек уменьшен для лучшей визуализации alpha=0.6 ) plt.colorbar(scatter_map_pca, label='Прогнозная толщина (м)') plt.title('Карта прогнозных толщин (PCA + KNN) - Весь датасет') plt.xlabel('Inline') plt.ylabel('Crossline') plt.show() # Визуализация карты для Автокодировщика + KNN plt.figure(figsize=(15, 8)) scatter_map_ae = plt.scatter( dataset_autoencoder['inline'], dataset_autoencoder['crossline'], c=dataset_autoencoder['predicted_thickness_ae'], cmap='turbo', s=1, alpha=0.6 ) plt.colorbar(scatter_map_ae, label='Прогнозная толщина (м)') plt.title('Карта прогнозных толщин (Autoencoder + KNN) - Весь датасет') plt.xlabel('Inline') plt.ylabel('Crossline') plt.show()Дополнительные Оптимизации и Рекомендации
-
Память: Если объём данных превышает возможности оперативной памяти, рассмотрите использование библиотек, поддерживающих работу с большими наборами данных, например, Dask для распределённых вычислений или Vaex для эффективной обработки больших таблиц.
-
Скорость Обработки: Для ускорения вычислений:
- Используйте многопоточность/многопроцессорность там, где это возможно (например,
n_jobs=-1вKNeighborsRegressor). - Рассмотрите использование методов сокращения размерности, оптимизированных для больших данных, например, t-SNE или UMAP, хотя они требуют больше вычислительных ресурсов.
- Используйте многопоточность/многопроцессорность там, где это возможно (например,
-
Визуализация:
- Для больших наборов данных визуализация всех точек может быть перегружающей и неинформативной. Рассмотрите использование выборок или агрегации (например, тепловых карт).
- Можно использовать инструменты визуализации, поддерживающие интерактивные графики (например, Plotly или Datashader), которые лучше справляются с большими объёмами данных.
-
Сохранение и Загрузка Моделей/Предсказаний:
- Для повторного использования обученных моделей или предсказаний сохраняйте их на диск с помощью
pickleили специализированных методов сохранения в Keras и scikit-learn. - Это особенно полезно при длительном обучении на больших наборах данных.
- Для повторного использования обученных моделей или предсказаний сохраняйте их на диск с помощью
-
Мониторинг и Логирование:
- При обработке больших объёмов данных полезно добавлять логирование прогресса (например, с помощью библиотеки
tqdmдля прогресс-баров), чтобы отслеживать статус выполнения процессов.
- При обработке больших объёмов данных полезно добавлять логирование прогресса (например, с помощью библиотеки
Пример Использования
tqdmдля Прогресс-бараfrom tqdm import tqdm selected_traces = [] selected_coords = [] for _, row in tqdm(merged_df.iterrows(), total=merged_df.shape[0], desc="Обработка трасс"): il = row['inline'] xl = row['crossline'] time_ms = row['time_ms'] trace_idx = il_xl_to_trace_idx.get((il, xl)) if trace_idx is None: continue trace = seg.trace[trace_idx] window_size_samples = 30 half_window = window_size_samples // 2 center_sample = int(time_ms / sample_rate_ms) start_sample = center_sample - half_window end_sample = center_sample + half_window if start_sample < 0 or end_sample > len(trace): continue trace_window = trace[start_sample:end_sample] rms = np.sqrt(np.mean(trace_window**2)) if rms == 0: trace_normalized = trace_window else: trace_normalized = trace_window / rms selected_traces.append(trace_normalized) selected_coords.append((il, xl))Заключение
Обработка больших объёмов данных требует серьёзного подхода к оптимизации как по памяти, так и по скорости выполнения. Приведённые выше изменения и рекомендации помогут вам использовать весь набор данных для вычисления главных компонент и обучения автокодировщика, что, несомненно, улучшит качество моделей и визуализаций. Если у вас возникнут дополнительные вопросы или потребуется помощь с реализацией каких-либо из предложенных оптимизаций, пожалуйста, дайте знать!
-