import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 1 input channel, 32 filters
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 13 * 13, 10)  # Assuming input 28x28

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 32 * 13 * 13)  # Flatten
        x = self.fc1(x)
        return x

x = x.view(x.size(0), -1)

import torch.nn as nn
import torch.nn.functional as F

class FullCNN(nn.Module):
    def __init__(self):
        super(FullCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # assumes input 28x28
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))   # 28x28 -> 14x14
        x = self.pool(F.relu(self.conv2(x)))   # 14x14 -> 7x7
        x = x.view(-1, 64 * 7 * 7)             # Flatten
        x = F.relu(self.fc1(x))
        x = self.fc2(x)                        # Output layer
        return x

import torch
print(f"PyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")

# From Python list
a = torch.tensor([1, 2, 3])  # 1D tensor (vector)

# 2D tensor (matrix)
b = torch.tensor([[1., 2.], [3., 4.]])

# Special tensors
zeros = torch.zeros(2, 3)      # 2x3 matrix of zeros
ones = torch.ones_like(zeros)  # Same shape as zeros, filled with 1s
rand = torch.rand(3, 3)        # 3x3 matrix with uniform random values (0-1)

x = torch.rand(2, 3)
print(f"Shape: {x.shape}")      # torch.Size([2, 3])
print(f"Data type: {x.dtype}")  # torch.float32
print(f"Device: {x.device}")    # cpu/cuda:0

if torch.cuda.is_available():
    x = x.to('cuda')  # Move to GPU
    print(f"Now on: {x.device}")  # cuda:0

x = torch.tensor([1., 2., 3.])
y = torch.tensor([4., 5., 6.])

# Element-wise operations
add = x + y        # or torch.add(x, y)
sub = x - y
mul = x * y
div = x / y

# Matrix multiplication
mat1 = torch.rand(2, 3)
mat2 = torch.rand(3, 2)
matmul = torch.mm(mat1, mat2)  # or mat1 @ mat2

x = torch.arange(6)          # [0, 1, 2, 3, 4, 5]
x_reshaped = x.view(2, 3)    # [[0, 1, 2], [3, 4, 5]]
x_flattened = x.flatten()    # Back to 1D

x = torch.tensor([[1, 2], [3, 4], [5, 6]])
print(x[0, 1])    # 2 (first row, second column)
print(x[:, 0])    # [1, 3, 5] (all rows, first column)

x = torch.tensor(2.0, requires_grad=True)
y = x**2 + 3*x + 1
y.backward()      # Compute gradients
print(x.grad)     # dy/dx = 2x + 3 → 7.0

# Simple linear regression
w = torch.randn(1, requires_grad=True)
b = torch.zeros(1, requires_grad=True)

# Forward pass
inputs = torch.tensor([[1.0], [2.0], [3.0]])
targets = torch.tensor([[2.0], [4.0], [6.0]])
predictions = inputs * w + b

# Loss and backward pass
loss = torch.mean((predictions - targets)**2)
loss.backward()  # Computes dloss/dw, dloss/db

print(f"Gradient of w: {w.grad}")
print(f"Gradient of b: {b.grad}")

import torch.nn as nn

class Perceptron(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.linear = nn.Linear(input_dim, 1)  # 1 output neuron
        
    def forward(self, x):
        return torch.sigmoid(self.linear(x))  # Sigmoid for probability

model = Perceptron(input_dim=2)
print(model)

# XOR-like dataset
X = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, TensorDataset

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

class DNN(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size):
        super().__init__()
        layers = []
        
        # Hidden layers
        prev_size = input_size
        for hidden_size in hidden_sizes:
            layers.append(nn.Linear(prev_size, hidden_size))
            layers.append(nn.ReLU())
            prev_size = hidden_size
            
        # Output layer (no activation for regression)
        layers.append(nn.Linear(prev_size, output_size))
        
        self.net = nn.Sequential(*layers)
        
    def forward(self, x):
        return self.net(x)

# Example: 3-layer network (input=10, hidden=[64,32], output=1)
model = DNN(10, [64, 32], 1).to(device)
print(model)

x = torch.linspace(-5, 5, 100)
activations = {
    "ReLU": nn.ReLU()(x),
    "LeakyReLU": nn.LeakyReLU(0.1)(x),
    "Sigmoid": nn.Sigmoid()(x),
    "Tanh": nn.Tanh()(x)
}

plt.figure(figsize=(12, 4))
for i, (name, y) in enumerate(activations.items()):
    plt.subplot(1, 4, i+1)
    plt.plot(x.numpy(), y.numpy())
    plt.title(name)
plt.tight_layout()
plt.show()

#VisionTransformer #ViT #DeepLearning #ComputerVision #Transformers #AI #MachineLearning #NeuralNetworks #ImageClassification #AttentionIsAllYouNeed

✉️ Our Telegram channels: https://yangx.top/addlist/0f6vfFbEMdAwODBk

📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A