Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as…

  1. 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 / 1000

    traces = 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 значениям, что были в обучении, а по всем трассам.

  2. 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()
    

    Дополнительные Оптимизации и Рекомендации

    1. Память: Если объём данных превышает возможности оперативной памяти, рассмотрите использование библиотек, поддерживающих работу с большими наборами данных, например, Dask для распределённых вычислений или Vaex для эффективной обработки больших таблиц.

    2. Скорость Обработки: Для ускорения вычислений:

      • Используйте многопоточность/многопроцессорность там, где это возможно (например, n_jobs=-1 в KNeighborsRegressor).
      • Рассмотрите использование методов сокращения размерности, оптимизированных для больших данных, например, t-SNE или UMAP, хотя они требуют больше вычислительных ресурсов.
    3. Визуализация:

      • Для больших наборов данных визуализация всех точек может быть перегружающей и неинформативной. Рассмотрите использование выборок или агрегации (например, тепловых карт).
      • Можно использовать инструменты визуализации, поддерживающие интерактивные графики (например, Plotly или Datashader), которые лучше справляются с большими объёмами данных.
    4. Сохранение и Загрузка Моделей/Предсказаний:

      • Для повторного использования обученных моделей или предсказаний сохраняйте их на диск с помощью pickle или специализированных методов сохранения в Keras и scikit-learn.
      • Это особенно полезно при длительном обучении на больших наборах данных.
    5. Мониторинг и Логирование:

      • При обработке больших объёмов данных полезно добавлять логирование прогресса (например, с помощью библиотеки 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))
    

    Заключение

    Обработка больших объёмов данных требует серьёзного подхода к оптимизации как по памяти, так и по скорости выполнения. Приведённые выше изменения и рекомендации помогут вам использовать весь набор данных для вычисления главных компонент и обучения автокодировщика, что, несомненно, улучшит качество моделей и визуализаций. Если у вас возникнут дополнительные вопросы или потребуется помощь с реализацией каких-либо из предложенных оптимизаций, пожалуйста, дайте знать!