import torch
print(torch.__version__)
print(torch.version.cuda)
print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

pip install GPUtil

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, TensorDataset
import time
import numpy as np
import GPUtil  # Optional, for memory usage

# ✅ Use GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# ✅ Create synthetic image dataset (28x28 like MNIST)
X = torch.randn(10000, 1, 28, 28)
y = torch.randint(0, 10, (10000,))

dataset = TensorDataset(X, y)
loader = DataLoader(dataset, batch_size=128, shuffle=True)

# ✅ Define a small CNN
class TestNet(nn.Module):
    def __init__(self):
        super(TestNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
        self.fc1 = nn.Linear(64 * 12 * 12, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = torch.flatten(x, 1)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

model = TestNet().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

# ✅ Train and time each epoch
epochs = 5
total_start = time.time()

for epoch in range(epochs):
    start = time.time()
    model.train()
    total_loss = 0
    correct = 0

    for inputs, labels in loader:
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        pred = outputs.argmax(dim=1)
        correct += (pred == labels).sum().item()

    end = time.time()
    accuracy = correct / len(dataset)
    print(f"Epoch {epoch+1}/{epochs} - Loss: {total_loss:.2f} - Accuracy: {accuracy:.4f} - Time: {end - start:.2f}s")

total_end = time.time()
print(f"\n⏱️ Total Training Time: {total_end - total_start:.2f}s")

# ✅ (Optional) Show GPU memory stats
try:
    gpus = GPUtil.getGPUs()
    for gpu in gpus:
        print(f"\n📊 GPU Utilization Report for {gpu.name}")
        print(f"  Load       : {gpu.load * 100:.1f}%")
        print(f"  Memory Used: {gpu.memoryUsed} MB / {gpu.memoryTotal} MB")
        print(f"  Temp       : {gpu.temperature} °C")
except:
    print("Install GPUtil via: pip install gputil")

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import time
import GPUtil

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"🖥️ Using device: {device}")

# ✅ Load CIFAR-10 dataset (auto-downloads)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=128, shuffle=True, num_workers=2)

# ✅ Load pretrained ResNet18 and adapt it
resnet18 = torchvision.models.resnet18(weights=None)  # or use weights="DEFAULT" for pretrained
resnet18.fc = nn.Linear(resnet18.fc.in_features, 10)
model = resnet18.to(device)

# ✅ Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# ✅ Train for multiple epochs
epochs = 20
total_start = time.time()

for epoch in range(epochs):
    start = time.time()
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for i, data in enumerate(train_loader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    end = time.time()
    accuracy = 100 * correct / total
    print(f"Epoch [{epoch + 1}/{epochs}] - Loss: {running_loss:.2f} - Accuracy: {accuracy:.2f}% - Time: {end - start:.2f}s")

total_end = time.time()
print(f"\n⏱️ Total Training Time: {total_end - total_start:.2f}s")

# ✅ GPU stats
try:
    gpus = GPUtil.getGPUs()
    for gpu in gpus:
        print(f"\n📊 GPU Stats for {gpu.name}")
        print(f"  Load       : {gpu.load * 100:.1f}%")
        print(f"  Memory Used: {gpu.memoryUsed} MB / {gpu.memoryTotal} MB")
        print(f"  Temp       : {gpu.temperature} °C")
except:
    print("Install GPUtil for GPU stats: pip install gputil")