I can't match in 3. graphic

[barkinadiguzel]

video: PyTorch 101 Crash Course For Beginners in 2025 | Daniel Bourke
timestamp: around 8hours
I have a problem in my 3th graph its dont match with my x_test

# amacımız datayı numberlara çevir öğrenmesini sağla
import torch
from torch import nn # sinir ağları için nn
import matplotlib.pyplot as plt
import torch.optim as optim
from pathlib import Path
bias = 0.3 # veri üretiminde kullanılacak gerçek bias
weight = 0.78 # veri üretiminde kullanılacak gerçek weight

X = torch.arange(0,1,0.02).unsqueeze(dim=1) # 0-1 arası veriyi 0.02 adımla oluştur ve (N,1) şekline getir
Y = weight * X + bias # doğrusal ilişkiyi uygula
print(X, "\n", Y) # X ve Y verilerini yazdır
print(X.shape) # X'in boyutunu kontrol et

train_split = int(0.8 * len(X)) # verinin %80'ini train, %20'sini test için ayır
x_train,y_train = X[:train_split], Y[:train_split] # eğitim verisi
x_test, y_test = X[train_split:], Y[train_split:] # test verisi
print(len (x_train), end=" "),print(len (y_train), end=" "),print(len(x_test), end=" "),print(len(y_test)) # boyutları yazdır

# Tahminleri ve gerçek veriyi görselleştirmek için fonksiyon
def plot_predictions(train_data=x_train,
                     train_labels=y_train,
                     test_data=x_test,
                     test_labels=y_test,
                     predictions=None):
    
    plt.figure(figsize=(10, 7)) # grafiğin boyutu
    plt.scatter(train_data, train_labels, c="b", s=4, label="Eğitim verisi") # eğitim verisini mavi ile
    plt.scatter(test_data, test_labels, c="g", s=4, label="Test verisi") # test verisini yeşil ile
    
    if predictions is not None:
        plt.scatter(test_data, predictions, c="r", s=4, label="Tahminler") # tahminleri kırmızı ile
    
    plt.xlabel("X") # x ekseni etiketi
    plt.ylabel("Y") # y ekseni etiketi
    plt.legend() # legend göster
    plt.show() # grafiği göster


print("-----------------------")
print("-----------------------")
print("-----------------------")

#plot_predictions() # orijinal veri dağılımını görselleştir

# Linear Regression Model
class LinearRegressionModel(nn.Module):
    def __init__(self):
        super().__init__()
        # weights ve bias'ı nn.Parameter ile tanımlıyoruz
        # Böylece optimizer bu değerleri güncelleyebilir
        self.weights = nn.Parameter(torch.randn(1, dtype=torch.float, requires_grad=True)) # rastgele ağırlık
        self.bias = nn.Parameter(torch.randn(1, dtype=torch.float, requires_grad=True)) # rastgele bias

    def forward(self, x: torch.Tensor):
        # Linear regression formülü: y = w*x + b
        return self.weights * x + self.bias

torch.manual_seed(42) # rastgeleliği kontrol altına almak için seed
# Modeli oluştur
model0 = LinearRegressionModel()

# Modelin parametrelerini yazdır
print(list(model0.parameters()))

with torch.inference_mode(): # eğitim yapmıyorsun, sadece tahmin. torch.no_grad() benzer iş yapar
    y_preds = model0(x_test) # test verisi üzerinden tahmin

print(y_preds, "------") 
print(y_test) 
plot_predictions(predictions=y_preds)
# Create empty loss lists to track values
train_loss_values = []
test_loss_values = []
epoch_count = []

loss_fn = nn.L1Loss() # kayıp fonksiyonu: L1 Loss (Ortalama Mutlak Hata)
optimizer = torch.optim.SGD(model0.parameters(), # optimizer: Stokastik Gradient Descent
                            lr=0.01) # öğrenme hızı
epochs = 1000 # toplam epoch sayısı
print(f"{model0.state_dict()}")
for epoch in range(epochs):
    model0.train() # model training moduna geç

    y_pred = model0(x_train) # train verisi ile tahmin
    loss = loss_fn(y_pred, y_train) # kaybı hesapla
    optimizer.zero_grad() # önceki gradientleri sıfırla
    loss.backward() # gradientleri hesapla
    optimizer.step() # ağırlıkları güncelle
    
    with torch.inference_mode():  # gradient hesaplamayı kapat
        y_preds = model0(x_test)  # test verisi üzerinden tahmin
        test_loss = loss_fn(y_preds, y_test)
    # Durumu yazdır
    epoch_count.append(epoch)
    train_loss_values.append(loss.detach().numpy())
    test_loss_values.append(test_loss.detach().numpy())
    if epoch % 10 == 0:
        print(f"Epoch: {epoch} | MAE Train Loss: {loss} | MAE Test Loss: {test_loss} ")

print(f"{model0.state_dict()}")
# Eğitim sonrası tahminleri aldıktan sonra
model0.eval()  # model değerlendirme moduna geç

plot_predictions(predictions=y_preds)
print(f"{loss}")
# Kayıp değerlerini çiz
plt.plot(epoch_count, train_loss_values, label="Train Loss")
plt.plot(epoch_count, test_loss_values, label="Test Loss")

plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.title("Train vs Test Loss")
plt.legend()
plt.show()

from pathlib import Path
# Python'un pathlib kütüphanesini import ediyoruz
# Dosya ve klasör yollarını platformdan bağımsız yönetmemizi sağlar

# 1. models klasörünü oluştur 
MODEL_PATH = Path("models")  
# "models" adında bir klasör yolu tanımlıyoruz

MODEL_PATH.mkdir(parents=True, exist_ok=True)  
# mkdir ile klasörü oluşturuyoruz
# parents=True → üst dizinler yoksa onları da oluşturur
# exist_ok=True → klasör zaten varsa hata vermez

# 2. Kaydedilecek model dosyası yolu oluştur 
MODEL_NAME = "01_pytorch_workflow_model_0.pth"  
# Kaydedilecek model dosyasının adını belirliyoruz

MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME  
# Klasör yolu ile dosya adını birleştiriyoruz
# / operatörü pathlib ile güvenli şekilde path birleştirmek için kullanılır

# 3. Modeli kaydet
print(f"Saving model to: {MODEL_SAVE_PATH}")  
# Kaydedilecek dosya yolunu ekrana yazdırıyoruz

torch.save(obj=model0.state_dict(),  # sadece modelin öğrenilmiş parametrelerini kaydediyoruz
           f=MODEL_SAVE_PATH)  
# model.state_dict() → ağırlık ve bias gibi öğrenilmiş parametreleri içerir
# torch.save ile bu parametreleri MODEL_SAVE_PATH'e kaydediyoruz

model0 = LinearRegressionModel()
model0.load_state_dict(torch.load(Path("models") / "01_pytorch_workflow_model_0.pth"))

# Subclass nn.Module to make our model
class LinearRegressionModelV2(nn.Module):
    def __init__(self):
        super().__init__()
        # nn.Linear() ile model parametrelerini oluştur
        self.linear_layer = nn.Linear(in_features=1, 
                                      out_features=1)
    
    # Forward computation tanımla (input x nn.Linear() üzerinden geçer)
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.linear_layer(x)

# Rastgeleliği kontrol altına almak için seed
torch.manual_seed(42)
model_1 = LinearRegressionModelV2()
model_1, model_1.state_dict()

device = "cuda" if torch.cuda.is_available() else "cpu"

# Model cihazını kontrol et
next(model_1.parameters()).device
# GPU varsa modele ata, yoksa CPU kullanılır
model_1.to(device)
next(model_1.parameters()).device

# Kayıp fonksiyonu oluştur
loss_fn = nn.L1Loss()

# Optimizer oluştur
optimizer = torch.optim.SGD(params=model_1.parameters(), # yeni modelin parametrelerini optimize et
                            lr=0.01)

torch.manual_seed(42)

# Epoch sayısını belirle
epochs = 10000 

# Verileri cihaz üzerinde tut
X_train = x_train.to(device)
X_test = x_test.to(device)
y_train = y_train.to(device)
y_test = y_test.to(device)

for epoch in range(epochs):
    ### Eğitim
    model_1.train() # train modu açık

    # 1. Forward pass
    y_pred = model_1(X_train)

    # 2. Kayıp hesapla
    loss = loss_fn(y_pred, y_train)

    # 3. Optimizer grad sıfırla
    optimizer.zero_grad()

    # 4. Backward pass
    loss.backward()

    # 5. Ağırlıkları güncelle
    optimizer.step()

    ### Test
    model_1.eval() # değerlendirme moduna geç
    # 1. Forward pass
    with torch.inference_mode():
        test_pred = model_1(X_test)
        # 2. Test kaybı hesapla
        test_loss = loss_fn(test_pred, y_test)

    if epoch % 100 == 0:
        print(f"Epoch: {epoch} | Train loss: {loss} | Test loss: {test_loss}")
        
# Modelin öğrendiği ağırlık ve bias değerlerini göster
from pprint import pprint # güzel yazdırma için
print("Modelin öğrendiği weights ve bias değerleri:")
pprint(model_1.state_dict())
print("\nOrijinal weights ve bias değerleri:")
print(f"weights: {weight}, bias: {bias}")

# Modeli değerlendirme moduna al
model_1.eval()

# Test verisi üzerinden tahmin yap
with torch.inference_mode():
    y_preds = model_1(X_test)
y_preds

plot_predictions(
    test_data=X_test.squeeze().cpu(),     # (N,) shape ve CPU
    test_labels=y_test.squeeze().cpu(),   # (N,) shape ve CPU
    predictions=y_preds.squeeze().cpu()   # (N,) shape ve CPU
)