PyTorch

# Из списка Python
x = torch.tensor([[1, 2], [3, 4]])

# С определенным типом данных
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float32)

# Заполнение нулями
x = torch.zeros(2, 3)

# Заполнение единицами
x = torch.ones(2, 3)

# Случайные значения из нормального распределения
x = torch.randn(2, 3)

# Случайные значения из равномерного распределения [0, 1)
x = torch.rand(2, 3)

# Единичная матрица
x = torch.eye(3)

# Из NumPy массива
import numpy as np
numpy_array = np.random.rand(2, 3)
x = torch.from_numpy(numpy_array)

# Изменение размерности
x = torch.randn(4, 4)
y = x.view(16)  # преобразование в одномерный тензор
z = x.view(-1, 8)  # -1 автоматически определяет размер

# Конкатенация тензоров
a = torch.randn(2, 3)
b = torch.randn(2, 3)
c = torch.cat([a, b], dim=0)  # по первому измерению
d = torch.cat([a, b], dim=1)  # по второму измерению

# Расширение размерности
x = torch.randn(2, 3)
y = x.unsqueeze(0)  # добавляет измерение в начало
z = x.unsqueeze(1)  # добавляет измерение после первого

# Сжатие размерности
x = torch.randn(1, 2, 3)
y = x.squeeze()  # удаляет все измерения размера 1
z = x.squeeze(0)  # удаляет указанное измерение, если его размер 1

# Индексирование как в Python
x = torch.randn(4, 3)
print(x[0])  # первая строка
print(x[:, 1])  # второй столбец
print(x[0, 1])  # элемент в первой строке, втором столбце

# Индексирование с помощью тензора
indices = torch.tensor([0, 2])
print(x[indices])  # выбирает строки с указанными индексами

# Булево индексирование
mask = x > 0
print(x[mask])  # выбирает элементы, где условие истинно

# Создание тензоров с возможностью вычисления градиентов
x = torch.randn(2, 2, requires_grad=True)
y = torch.randn(2, 2, requires_grad=True)

# Выполнение операций
z = x * y
out = z.mean()

# Вычисление градиентов
out.backward()

# Доступ к градиентам
print(x.grad)  # d(out)/dx
print(y.grad)  # d(out)/dy

# Проверка доступности CUDA
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# Проверка количества доступных GPU
if torch.cuda.is_available():
    num_gpus = torch.cuda.device_count()
    print(f"Available GPUs: {num_gpus}")
    for i in range(num_gpus):
        print(f"GPU {i}: {torch.cuda.get_device_name(i)}")

# Создание тензора на GPU
x = torch.randn(10, 10, device=device)
# или
x = torch.randn(10, 10).to(device)

# Перемещение тензора между устройствами
x_cpu = x.cpu()
x_gpu = x_cpu.cuda()  # или x_cpu.to('cuda')

# Указание конкретного GPU
if torch.cuda.device_count() > 1:
    x_gpu1 = torch.randn(10, 10, device="cuda:1")  # второй GPU

# Перемещение всей модели на GPU
model = MyModel()
model = model.to(device)

# Если нужно использовать несколько GPU
if torch.cuda.device_count() > 1:
    print(f"Using {torch.cuda.device_count()} GPUs")
    model = nn.DataParallel(model)
    
model = model.to(device)

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# Генерация данных
np.random.seed(42)
x = np.random.rand(100, 1)
y = 1 + 2 * x + 0.1 * np.random.randn(100, 1)  # y = 1 + 2x + шум

# Преобразование в тензоры
x_tensor = torch.from_numpy(x).float()
y_tensor = torch.from_numpy(y).float()

# Определение модели
class LinearRegression(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)
        
    def forward(self, x):
        return self.linear(x)
    
model = LinearRegression()

# Функция потерь и оптимизатор
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# Обучение модели
epochs = 100
losses = []

for epoch in range(epochs):
    # Прямой проход
    y_pred = model(x_tensor)
    
    # Вычисление потерь
    loss = criterion(y_pred, y_tensor)
    losses.append(loss.item())
    
    # Обратное распространение
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
        
# Получение параметров модели
w = model.linear.weight.item()
b = model.linear.bias.item()
print(f'Параметры модели: w = {w:.4f}, b = {b:.4f}')

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

# Определение преобразований
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# Загрузка данных MNIST
train_dataset = torchvision.datasets.MNIST(
    root='./data', train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.MNIST(
    root='./data', train=False, transform=transform, download=True)

train_loader = torch.utils.data.DataLoader(
    train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    test_dataset, batch_size=1000, shuffle=False)

# Определение CNN модели
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(-1, 64 * 7 * 7)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# Инициализация модели, функции потерь и оптимизатора
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Обучение модели
num_epochs = 5

for epoch in range(num_epochs):
    running_loss = 0.0
    
    for i, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        labels = labels.to(device)
        
        # Прямой проход
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Обратное распространение
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        
        if (i+1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {running_loss/100:.4f}')
            running_loss = 0.0
    
    # Оценка на тестовом наборе
    model.eval()
    with torch.no_grad():
        correct = 0
        total = 0
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        print(f'Accuracy: {100 * correct / total:.2f}%')