PyTorch: Model و nn.Module

import torch
import torch.nn as nn

class LinearRegression(nn.Module):
    def __init__(self, in_features, out_features):
        super().__init__()
        self.linear = nn.Linear(in_features, out_features)

    def forward(self, x):
        return self.linear(x)

model = LinearRegression(in_features=3, out_features=1)
print(model)

LinearRegression(
  (linear): Linear(in_features=3, out_features=1, bias=True)
)

for name, param in model.named_parameters():
    print(f"{name}: {param.shape}")

linear.weight: torch.Size([1, 3])
linear.bias:   torch.Size([1])

class TwoLayerMLP(nn.Module):
    def __init__(self, in_features, hidden, out_features):
        super().__init__()
        self.fc1 = nn.Linear(in_features, hidden)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden, out_features)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = TwoLayerMLP(in_features=4, hidden=8, out_features=3)
print(model)

TwoLayerMLP(
  (fc1): Linear(in_features=4, hidden=8, bias=True)
  (relu): ReLU()
  (fc2): Linear(hidden=8, out_features=3, bias=True)
)

total = 0
for name, param in model.named_parameters():
    print(f"{name:12s} {str(param.shape):20s} numel={param.numel()}")
    total += param.numel()

print(f"\nTotal parameters: {total}")

fc1.weight   torch.Size([8, 4])      numel=32
fc1.bias     torch.Size([8])         numel=8
fc2.weight   torch.Size([3, 8])      numel=24
fc2.bias     torch.Size([3])         numel=3

Total parameters: 67

torch.manual_seed(0)
model = TwoLayerMLP(in_features=4, hidden=8, out_features=3)

x = torch.randn(5, 4)        # 5 عيّنات، 4 ميزات لكل واحدة
y_hat = model(x)
print("input shape:", x.shape)         # (5, 4)
print("output shape:", y_hat.shape)    # (5, 3)

# ✅ الصحيح
y_hat = model(x)

# ❌ تجنّب هذا
y_hat = model.forward(x)

model = nn.Sequential(
    nn.Linear(4, 8),
    nn.ReLU(),
    nn.Linear(8, 3),
)

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

# عند التدريب، انقل البيانات إلى نفس الجهاز:
# x, y = x.to(device), y.to(device)
y_hat = model(x)

model.train()    # للتدريب — Dropout مفعّل
y_hat = model(x)
loss = criterion(y_hat, y)
loss.backward()
optimizer.step()

model.eval()     # للتقييم — Dropout معطّل
with torch.no_grad():
    y_hat = model(x_val)

import torch
import torch.nn as nn

torch.manual_seed(0)

class TinyRegressor(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(1, 8),
            nn.ReLU(),
            nn.Linear(8, 1),
        )

    def forward(self, x):
        return self.net(x)

model = TinyRegressor()
x = torch.linspace(-1, 1, 100).unsqueeze(1)   # (100, 1)
y = 3 * x + 0.5 + 0.1 * torch.randn_like(x)

criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-1)

for epoch in range(200):
    y_hat = model(x)
    loss = criterion(y_hat, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

print(f"final loss: {loss.item():.4f}")

# فحص المعاملات
w = list(model.parameters())[0].item()
b = list(model.parameters())[2].item()
print(f"w ≈ {w:.2f} (target: 3.0), b ≈ {b:.2f} (target: 0.5)")

final loss: 0.0085
w ≈ 2.98, b ≈ 0.51