Makine Öğrenimi - Python GRU (Gated Recurrent Unit)

algoritma · 31 Eki 2023

GRU (Gated Recurrent Unit)

Gated Recurrent Unit (GRU), sıralı verileri işlemek için kullanılan bir yapay sinir ağı türüdür ve özellikle Recurrent Neural Network (RNN) ailesinde kullanılır. GRU, zaman serileri analizi, metin işleme, çeviri, ve konuşma tanıma gibi sıralı veri analiz uygulamalarında etkili bir şekilde kullanılır. GRU, özellikle uzun vadeli bağımlılıkları yakalama yeteneği ve RNN'ye göre daha basit bir yapısı ile ön plana çıkar.

GRU'nun temel özellikleri şunlardır:

Gizli Durum (Hidden State): Her zaman adımında bir gizli durum bulunur. Gizli durum, önceki zaman adımlarından gelen bilgileri ve mevcut veriyi temsil eder.
Saldırganlı Kapı (Update Gate) ve Saldırganlık Kapısı (Reset Gate): GRU, iki önemli kapıyı içerir. Saldırganlık kapısı, gizli durumun ne kadar unutulacağını kontrol eder. Saldırganlık kapısı, hangi bilgilerin güncelleneceğini belirler. Bu, uzun vadeli bağımlılıkların daha iyi izlenmesine yardımcı olur.
Aktivasyon Fonksiyonları: GRU, her zaman adımında aktivasyon fonksiyonları kullanır. Bu fonksiyonlar, gelen veriyi işler ve gizli durumu günceller.

input_size: Bu, her zaman serisi örneğinin giriş boyutunu ifade eder. Yani, her bir zaman adımındaki veri noktasının boyutunu belirtir. Örneğin, bir hisse senedinin kapanış fiyatlarını kullanıyorsanız, bu 1 olacaktır, çünkü her zaman adımında sadece bir kapanış fiyatı verisi vardır.
hidden_size: Bu, GRU'nun içindeki gizli (hidden) hücrelerin sayısını ifade eder. Bu sayı, modelin karmaşıklığını ve kapasitesini belirler. Daha büyük bir hidden_size, modelin daha karmaşık örüntüleri öğrenme kapasitesine sahip olmasına neden olabilir, ancak aynı zamanda daha fazla hesaplama maliyetine ve daha fazla veriye ihtiyaç duyabilir.
output_size: Bu, modelin çıkış boyutunu ifade eder. Burada, yine her zaman serisi örneğinin çıkış boyutunu belirtirsiniz. Eğer gelecekteki tek bir zaman adımındaki fiyatı tahmin ediyorsanız, bu da 1 olacaktır.

input_size = 1 # Her zaman adımındaki giriş boyutu (örneğin, kapanış fiyatı)
hidden_size = 64 # GRU'nun gizli hücre sayısı
output_size = 1 # Her zaman adımındaki çıkış boyutu (örneğin, gelecekteki kapanış fiyatı tahmini)

GRU'nun avantajları şunlar olabilir:

Vanishing gradient sorununu azaltma: RNN'ye kıyasla GRU, vanishing gradient sorununu daha iyi ele alabilir ve daha uzun vadeli bağımlılıkları izleyebilir.
Basit yapısı: GRU, LSTM'ye göre daha az parametreye sahip ve daha az hesaplama gücü gerektirir.
Etkin bellek kullanımı: GRU, gizli durumunun güncellenmesi ve bilgi taşınması konusunda daha etkili bir şekilde belleği kullanır.

GRU, zaman serileri analizi, doğal dil işleme ve diğer sıralı veri analiz uygulamaları için etkili bir araçtır. Özellikle eğitim süreçlerinde hızlı ve veri açısından sınırlı durumlarda GRU, LSTM'ye tercih edilebilir. Ancak her iki model de farklı durumlarda kullanılabilir ve uygulamaya bağlı olarak tercih edilen seçenek değişebilir.

Kod:

import pandas as pd
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# CSV dosyasını yükle
file_path = 'xu100/tursg.is.csv'
data = pd.read_csv(file_path)

# Veriyi işleme
prices = data["Close"].values.reshape(-1, 1)
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(prices)

# Veriyi girdi ve çıktı olarak ayarla
X, y = [], []
look_back = 10  # Örneğin, son 10 günü kullanabilirsiniz
future_days = 10  # Bir sonraki günü tahmin etmek istiyoruz

for i in range(look_back, len(scaled_data) - future_days):
    X.append(scaled_data[i - look_back:i, 0])
    y.append(scaled_data[i + future_days, 0])

X, y = np.array(X), np.array(y)

# Veriyi torch Tensor'larına çevir
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32)

# TensorDataset ve DataLoader kullanarak veriyi yükleyin
dataset = TensorDataset(X_tensor, y_tensor)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)

# GRU modelini oluştur
class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(GRUModel, self).__init__()
        self.gru = nn.GRU(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        out, _ = self.gru(x)
        out = self.fc(out[:, -1, :])  # Sadece son zaman adımının çıktısını kullanıyoruz
        return out

# Modeli, kayıp fonksiyonunu ve optimizasyon algoritmasını tanımla
input_size = 1
hidden_size = 64
output_size = 1

model = GRUModel(input_size, hidden_size, output_size)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Modeli eğit
num_epochs = 10
for epoch in range(num_epochs):
    for batch_X, batch_y in dataloader:
        optimizer.zero_grad()
        outputs = model(batch_X.unsqueeze(-1))  # Modelin giriş boyutunu uygun hale getir
        loss = criterion(outputs, batch_y.unsqueeze(-1))
        loss.backward()
        optimizer.step()
# Veriyi eğitim ve test setlerine ayır
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Veriyi torch Tensor'larına çevir
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)

# TensorDataset ve DataLoader kullanarak veriyi yükleyin
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False)

# Test setinde modelin performansını değerlendir
X_test_tensor = X_tensor[-len(X_test):]
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)
y_pred_tensor = model(X_test_tensor.unsqueeze(-1))

mse = criterion(y_pred_tensor, y_test_tensor.unsqueeze(-1))
print("Mean Squared Error:", mse.item())

# Modeli kullanarak gelecekteki kapanış fiyatını tahmin et
# Modeli kullanarak gelecekteki kapanış fiyatını tahmin et
last_close_price = data["Close"].iloc[-1]

# Veriyi alın ve ölçeklendirin
last_window = scaled_data[-look_back:, 0]
last_window = last_window.reshape(1, look_back, 1)

# Modeli kullanarak gelecekteki fiyat tahminini yapın
predicted_price_scaled = model(torch.tensor(last_window, dtype=torch.float32))
predicted_price = scaler.inverse_transform(predicted_price_scaled.detach().numpy().reshape(-1, 1))[0][0]

print("En son kapanış fiyatı:", last_close_price)
print("Modelin tahmini gelecekteki fiyat:", predicted_price)

Teknik Analiz Dünyasına Hoşgeldiniz. Paylaşmak Güzeldir.

Makine Öğrenimi - Python GRU (Gated Recurrent Unit)

algoritma

Forumdan daha fazla yararlanmak için giriş yapın yada üye olun!