LSTM с Tramsformer

LSTM с Tramsformer

Приведенная ниже статья стала возможной благодаря #chatgpt. Эта статья призвана помочь просмотреть, переосмыслить и повторно использовать компоненты нескольких методов #ml для достижения лучших результатов при решении данной проблемы.

В частности, мы используем #LSTM и #transformer, мы будем использовать их оба для объединения в другую модель на более позднем этапе, а сейчас вот краткое введение в эти два метода.

Долгая кратковременная память

Заложить основу

Вы когда-нибудь играли в игру, в которой вам нужно запомнить ряд вещей, например, последовательность цветов или чисел? Может быть трудно удержать их все в голове сразу, верно?

Ну, это похоже на то, что делает компьютер, когда пытается понять последовательность вещей, например предложение. Он должен помнить, что было раньше, чтобы понять, что будет дальше.

С LSTM компьютер может запоминать важные вещи из более ранней последовательности и использовать эту информацию, чтобы понять, что будет дальше. Это может быть очень полезно, когда компьютер пытается делать такие вещи, как понимать речь, переводить языки или предсказывать, что может произойти дальше в фильме.

Так что в некотором смысле LSTM похожа на действительно умную память, которая помогает компьютеру лучше понимать последовательность вещей.

Разберем также еще одну технику

Трансформер

Хорошо, представьте, что у вас есть куча изображений разных животных, и вы хотите знать, какое животное изображено на каждом из них. Но вы еще не умеете читать, поэтому вы не можете посмотреть на слова под картинками, чтобы понять это.

Поэтому вместо этого вы просите своего друга, который умеет читать, помочь вам. Вам говорят название каждого животного на картинке, и вы его запоминаете. Через некоторое время вы сами начинаете узнавать животных и можете называть их без помощи друга.

А теперь представьте, что у вас МНОГО изображений животных, и вы не хотите каждый раз просить друга о помощи. Вот тут-то и появляется Трансформер. Это как очень умный друг, который может рассказать вам, что изображено на каждой картинке, и вам не нужно спрашивать.

Трансформер просматривает все картинки сразу и выясняет, что на каждой из них. Он делает это, обращая внимание на разные части изображений и сравнивая их друг с другом. Затем он говорит вам, что, по его мнению, изображено на каждой картинке.

Таким образом, вместо того, чтобы каждый раз просить своего друга читать слова для вас, вы можете просто использовать Трансформер, чтобы помочь вам понять, что изображено на картинках. Это как иметь действительно умного друга, который может читать для тебя все время!

Пример кода LsTM

from keras.models import Sequential
from keras.layers import LSTM, Dense
import numpy as np

# Generate some random data for the input
data = np.random.rand(1000, 10)

# Create the LSTM model
model = Sequential()
model.add(LSTM(32, input_shape=(10, 1)))
model.add(Dense(1, activation='sigmoid'))

# Compile the model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Reshape the input data to fit the model's expected shape
data = np.reshape(data, (1000, 10, 1))

# Train the model
model.fit(data, np.random.randint(2, size=(1000, 1)), epochs=10, batch_size=32)

# Use the model to make predictions on new data
new_data = np.random.rand(1, 10, 1)
predictions = model.predict(new_data)

print(predictions)

• из keras.models импортировать Sequential
из keras.layers импортировать Dense, LSTM

. # Определить модель LSTM
• model = Sequential()
• model.add(LSTM(128, input_shape=(10, 1))) # 128 — количество единиц/нейронов в слое LSTM
• model.add(Dense(1,activation='sigmoid')) # Добавляем плотный слой с одним выходным блоком и сигмовидной активацией
•
• # Скомпилируем модель
• model.compile(loss='binary_crossentropy', Optimizer='adam', metrics=['accuracy'])
•
• # Обучить модель
• X_train = [.. .] # Ваши входные данные формы (образцы, временные шаги, признаки)
• y_train = [...] # Ваши целевые данные формы (образцы)
• model.fit(X_train, y_train , epochs=10, batch_size=32)
•
• # Используйте модель для прогнозирования
• X_test = [...] # Ваши входные данные формы (выборки, временные шаги, особенности)
• y_pred = model.predict(X_test)
•

Пример кода трансформатора

import torch
import torch.nn as nn

class Transformer(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_heads, num_layers):
        super(Transformer, self).__init__()

        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.num_heads = num_heads
        self.num_layers = num_layers

        self.pos_encoder = PositionalEncoding(input_dim, dropout=0.1)

        encoder_layer = nn.TransformerEncoderLayer(d_model=input_dim, nhead=num_heads)
        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)

        self.linear = nn.Linear(input_dim, hidden_dim)
        self.output = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        x = self.pos_encoder(x)
        x = self.transformer_encoder(x)
        x = x.mean(dim=1)
        x = self.linear(x)
        x = nn.ReLU()(x)
        x = self.output(x)
        return x

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout=0.1, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0).transpose(0, 1)
        self.register_buffer('pe', pe)

    def forward(self, x):
        x = x + self.pe[:x.size(0), :]
        return self.dropout(x)

•
• импортировать torch
• импортировать torch.nn как nn
• импортировать torch.optim как optim
•
• класс Transformer(nn.Module):
• def __init__(self, vocab_size, d_model, nhead, dim_feedforward, num_layers):
• super(Transformer, self).__init__()
•
• self.embedding = nn. Embedding(vocab_size, d_model)
• self.pos_encoder = PositionalEncoding(d_model)
• encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward)
• self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
• self.decoder = nn.Linear(d_model, vocab_size)
• self.init_weights()
•
• def init_weights (self):
• initrange = 0,1
• self.embedding.weight.data.uniform_(-initrange, initrange)
• self.decoder.bias.data.zero_()
• self.decoder.weight.data.uniform_(-initrange, initrange)
•
• def forward(self, src, src_mask=None):
• src = self.embedding (src) * math.sqrt(self.d_model)
• src = self.pos_encoder(src)
• output = self.transformer_encoder(src, src_mask)
• output = self.decoder (output)
• return output
•
• # Создать экземпляр модели Transformer
• model = Transformer(vocab_size=10000, d_model=512, nhead=8, dim_feedforward=2048, num_layers=6)
•
• # Определяем функцию потерь и оптимизатор
• критерий = nn.CrossEntropyLoss()
• оптимизатор = optim.Adam(model.parameters(), lr=0.001)
•
• # Обучение модели
• для эпохи в диапазоне (num_epochs):
• для i, пакет в enumerate(data_loader):
• источник, tgt = пакет
• оптимизатор.zero_grad()
• вывод = модель (источник)
• потеря = критерий (вывод.представление(-1, вывод.размер(-1) ), tgt.view(-1))
• loss.backward()
• optimizer.step()
•
• # Используйте обученную модель для прогнозирования
• src = [...] # Ваши входные данные формы (batch_size, seq_len)
• output = model(src)