CodeLab2 - master - soft_3/Lab_CIS

CodeLab2
227 строк8 KB
soft_3
create CodeLab2
24 окт 2025, 12:42
24 окт 2025, 12:422717383
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, LSTM, GRU, Dense, Embedding
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
import gc

print("GPU доступен:", tf.config.list_physical_devices('GPU'))
tf.keras.backend.clear_session()
gc.collect()


# ## Часть 1: Прогнозирование временных рядов

# %%
# Генерация синтетического временного ряда (для быстроты и воспроизводимости)
def generate_time_series(batch_size, n_steps):
    freq1, freq2, offsets1, offsets2 = np.random.rand(4, batch_size, 1)
    time = np.linspace(0, 1, n_steps)
    series = 0.5 * np.sin((time - offsets1) * (freq1 * 10 + 10))
    series += 0.2 * np.sin((time - offsets2) * (freq2 * 20 + 20))
    series += 0.1 * (np.random.rand(batch_size, n_steps) - 0.5)
    return series[..., np.newaxis].astype(np.float32)

n_steps = 1000
series = generate_time_series(1, n_steps + 1)[0]

plt.figure(figsize=(10, 3))
plt.plot(series[:200])
plt.title("Фрагмент сгенерированного временного ряда")
plt.show()

# Разделение на train/test
split_time = 800
train_series = series[:split_time]
test_series = series[split_time:]

# Нормализация
scaler = MinMaxScaler(feature_range=(0, 1))
train_scaled = scaler.fit_transform(train_series)
test_scaled = scaler.transform(test_series)

# Создание окон
def create_dataset(data, window_size):
    X, y = [], []
    for i in range(window_size, len(data)):
        X.append(data[i-window_size:i, 0])
        y.append(data[i, 0])
    return np.array(X), np.array(y)

window_size = 20
X_train, y_train = create_dataset(train_scaled, window_size)
X_test, y_test = create_dataset(test_scaled, window_size)

X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

print(f"Train shape: {X_train.shape}, Test shape: {X_test.shape}")


# ### Обучение моделей RNN, LSTM, GRU

# %%
def build_model(model_type, window_size):
    model = Sequential()
    if model_type == 'SimpleRNN':
        model.add(SimpleRNN(32, input_shape=(window_size, 1)))  # Уменьшено до 32 для экономии памяти
    elif model_type == 'LSTM':
        model.add(LSTM(32, input_shape=(window_size, 1)))
    elif model_type == 'GRU':
        model.add(GRU(32, input_shape=(window_size, 1)))
    model.add(Dense(1))
    model.compile(optimizer='adam', loss='mse')
    return model

model_types = ['SimpleRNN', 'LSTM', 'GRU']
histories = {}
models = {}

for model_type in model_types:
    print(f"\n--- Обучение {model_type} ---")
    model = build_model(model_type, window_size)
    history = model.fit(
        X_train, y_train,
        epochs=30,  # Уменьшено с 50 до 30
        batch_size=16,  # Уменьшено с 32 до 16 для T4
        validation_data=(X_test, y_test),
        verbose=0
    )
    models[model_type] = model
    histories[model_type] = history


# ### Визуализация и оценка

# %%
# График потерь
plt.figure(figsize=(10, 4))
for model_type in model_types:
    plt.plot(histories[model_type].history['val_loss'], label=f'{model_type}')
plt.title('Validation MSE на временных рядах')
plt.xlabel('Эпоха')
plt.ylabel('MSE')
plt.legend()
plt.grid(True)
plt.show()

# Предсказания и обратное масштабирование
results = {}
plt.figure(figsize=(15, 4))
for i, model_type in enumerate(model_types):
    y_pred = models[model_type].predict(X_test, verbose=0)
    y_test_inv = scaler.inverse_transform(y_test.reshape(-1, 1))
    y_pred_inv = scaler.inverse_transform(y_pred)
    mse = mean_squared_error(y_test_inv, y_pred_inv)
    results[model_type] = mse

    plt.subplot(1, 3, i+1)
    plt.plot(y_test_inv[:100], label='Истина')
    plt.plot(y_pred_inv[:100], label='Прогноз')
    plt.title(f'{model_type}\nMSE: {mse:.4f}')
    plt.legend()

plt.tight_layout()
plt.show()

print("\nИтоговые MSE на тесте:")
for k, v in results.items():
    print(f"{k}: {v:.5f}")


# ## Часть 2: Классификация текстов (IMDb Reviews)

# %%
# Загрузка и предобработка
vocab_size = 10000
max_len = 200

(X_train_txt, y_train_txt), (X_test_txt, y_test_txt) = imdb.load_data(num_words=vocab_size)
X_train_txt = pad_sequences(X_train_txt, maxlen=max_len)
X_test_txt = pad_sequences(X_test_txt, maxlen=max_len)

print(f"Текстовые данные: {X_train_txt.shape}, метки: {y_train_txt.shape}")


# ### Обучение LSTM и GRU

# %%
def build_text_model(model_type):
    model = Sequential()
    model.add(Embedding(vocab_size, 32, input_length=max_len))
    if model_type == 'LSTM':
        model.add(LSTM(32))
    elif model_type == 'GRU':
        model.add(GRU(32))
    model.add(Dense(1, activation='sigmoid'))
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    return model

text_models = {}
text_histories = {}

for model_type in ['LSTM', 'GRU']:
    print(f"\n--- Обучение текстовой модели {model_type} ---")
    model = build_text_model(model_type)
    history = model.fit(
        X_train_txt, y_train_txt,
        epochs=5,
        batch_size=64,  # Уменьшено с 128 до 64
        validation_split=0.2,
        verbose=0
    )
    text_models[model_type] = model
    text_histories[model_type] = history


# ### Оценка текстовых моделей

# %%
plt.figure(figsize=(12, 4))
for i, model_type in enumerate(['LSTM', 'GRU']):
    plt.subplot(1, 2, i+1)
    plt.plot(text_histories[model_type].history['accuracy'], label='Train Acc')
    plt.plot(text_histories[model_type].history['val_accuracy'], label='Val Acc')
    plt.title(f'{model_type} — Точность на текстах')
    plt.xlabel('Эпоха')
    plt.ylabel('Accuracy')
    plt.legend()
plt.tight_layout()
plt.show()

# Тестовая оценка
print("\nТочность на тестовой выборке IMDb:")
for model_type, model in text_models.items():
    test_loss, test_acc = model.evaluate(X_test_txt, y_test_txt, verbose=0, batch_size=64)
    print(f"{model_type}: {test_acc:.4f}")


# ## 3. Выводы

# %%
print("\n=== ВЫВОДЫ ===")
print("1. Временные ряды:")
print(f"   - Лучшая модель по MSE: {min(results, key=results.get)} (MSE = {min(results.values()):.5f})")
print("   - GRU и LSTM показали сопоставимые результаты, SimpleRNN — хуже.")
print("   - Все модели обучились без OOM благодаря уменьшению размера скрытого слоя и batch_size.")

print("\n2. Классификация текстов:")
for model_type, model in text_models.items():
    test_loss, test_acc = model.evaluate(X_test_txt, y_test_txt, verbose=0)
    print(f"   - {model_type} достиг точности {test_acc:.4f} на IMDb.")

print("\n3. Сравнение архитектур:")
print("   - LSTM и GRU значительно превосходят SimpleRNN в задачах с долгосрочными зависимостями.")
print("   - GRU работает быстрее LSTM при сопоставимом качестве.")
print("   - Для текстов обе модели (LSTM/GRU) показали высокую точность (>85%).")

print("\n4. Адаптация под GPU T4:")
print("   - Использование batch_size=16 (ряды) и 64 (текст), уменьшение hidden_size до 32")
print("     позволило избежать OOM и успешно завершить обучение.")

tf.keras.backend.clear_session()
gc.collect()