Тензори та автоматичне диференціювання в PyTorch

import torch

print(f"PyTorch версія: {torch.__version__}")
print(f"CUDA доступна: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")

import torch

# Одновимірний тензор (вектор)
vector = torch.tensor([1, 2, 3, 4, 5])
print(f"Вектор: {vector}")
print(f"Форма: {vector.shape}")
print(f"Ранг: {vector.ndim}")

# Двовимірний тензор (матриця)
matrix = torch.tensor([
    [1, 2, 3],
    [4, 5, 6]
])
print(f"Матриця:\n{matrix}")
print(f"Форма: {matrix.shape}")
print(f"Ранг: {matrix.ndim}")

# Тривимірний тензор (наприклад, RGB зображення 2×2 пікселі)
image = torch.tensor([
    [[255, 0, 0], [0, 255, 0]],      # перший рядок пікселів
    [[0, 0, 255], [255, 255, 0]]     # другий рядок пікселів
])
print(f"Зображення:\n{image}")
print(f"Форма: {image.shape}")  # (висота, ширина, канали)

import numpy as np
import torch

# NumPy масив → PyTorch тензор
np_array = np.array([[1, 2, 3], [4, 5, 6]])
tensor = torch.from_numpy(np_array)

print(f"NumPy масив:\n{np_array}")
print(f"PyTorch тензор:\n{tensor}")
print(f"Тип даних NumPy: {np_array.dtype}")
print(f"Тип даних PyTorch: {tensor.dtype}")

# PyTorch тензор → NumPy масив
tensor = torch.tensor([[1.5, 2.5], [3.5, 4.5]])
np_array = tensor.numpy()

print(f"PyTorch тензор:\n{tensor}")
print(f"NumPy масив:\n{np_array}")

import torch

# Тензор, заповнений нулями
zeros = torch.zeros(3, 4)
print(f"Нулі (3×4):\n{zeros}\n")

# Тензор, заповнений одиницями
ones = torch.ones(2, 3)
print(f"Одиниці (2×3):\n{ones}\n")

# Одинична матриця (діагональ з одиниць)
identity = torch.eye(4)
print(f"Одинична матриця 4×4:\n{identity}")

# Послідовність чисел (як range у Python)
sequence = torch.arange(0, 10, 2)  # від 0 до 10 з кроком 2
print(f"Послідовність: {sequence}\n")

# Рівномірно розподілені числа (як linspace у NumPy)
linspace = torch.linspace(0, 1, 5)  # 5 чисел від 0 до 1
print(f"Linspace: {linspace}")

import torch

# Випадкові числа з рівномірного розподілу [0, 1)
uniform = torch.rand(2, 3)
print(f"Рівномірний розподіл [0, 1):\n{uniform}\n")

# Випадкові числа з нормального розподілу N(0, 1)
normal = torch.randn(2, 3)
print(f"Нормальний розподіл N(0, 1):\n{normal}\n")

# Випадкові цілі числа
randint = torch.randint(low=0, high=10, size=(3, 4))
print(f"Випадкові цілі [0, 10):\n{randint}")

import torch

# Без фіксації зерна — різні результати
print("Перший запуск:", torch.randn(3))
print("Другий запуск:", torch.randn(3))

# З фіксацією зерна — ідентичні результати
torch.manual_seed(42)
print("Перший запуск:", torch.randn(3))

torch.manual_seed(42)
print("Другий запуск:", torch.randn(3))

import torch

# За замовчуванням: float32 на CPU
default_tensor = torch.tensor([1.0, 2.0, 3.0])
print(f"Тип даних: {default_tensor.dtype}")
print(f"Пристрій: {default_tensor.device}\n")

# Явне задання типу даних
int_tensor = torch.tensor([1, 2, 3], dtype=torch.int32)
float64_tensor = torch.tensor([1.0, 2.0], dtype=torch.float64)

print(f"int32: {int_tensor} → dtype={int_tensor.dtype}")
print(f"float64: {float64_tensor} → dtype={float64_tensor.dtype}")

# Перевірка доступності GPU
if torch.cuda.is_available():
    # Створення тензора безпосередньо на GPU
    gpu_tensor = torch.tensor([1.0, 2.0, 3.0], device='cuda')
    print(f"GPU тензор: {gpu_tensor}")
    print(f"Пристрій: {gpu_tensor.device}")
    
    # Переміщення з CPU на GPU
    cpu_tensor = torch.tensor([4.0, 5.0, 6.0])
    gpu_tensor = cpu_tensor.to('cuda')
    print(f"\nПісля .to('cuda'): {gpu_tensor.device}")
else:
    print("GPU недоступна, використовуємо CPU")

import torch

tensor = torch.randn(3, 4, 5)

print(f"Форма (shape): {tensor.shape}")           # розміри по кожній вісі
print(f"Розмір (size): {tensor.size()}")          # те саме, що shape
print(f"Ранг (ndim): {tensor.ndim}")             # кількість вимірів
print(f"Кількість елементів: {tensor.numel()}")  # загальна кількість
print(f"Тип даних (dtype): {tensor.dtype}")      # тип чисел
print(f"Пристрій (device): {tensor.device}")     # CPU або GPU
print(f"Відстеження градієнтів: {tensor.requires_grad}")

import torch

# Початковий тензор 2×6
tensor = torch.arange(12).reshape(2, 6)
print(f"Оригінал (2×6):\n{tensor}\n")

# Зміна на 3×4 через view
view_tensor = tensor.view(3, 4)
print(f"view(3, 4):\n{view_tensor}\n")

# Зміна на 4×3 через reshape
reshape_tensor = tensor.reshape(4, 3)
print(f"reshape(4, 3):\n{reshape_tensor}")

# Автоматичне обчислення одного виміру через -1
tensor = torch.arange(24)
reshaped = tensor.view(2, -1)  # -1 автоматично стане 12 (бо 24 / 2 = 12)
print(f"view(2, -1):\n{reshaped}")
print(f"Форма: {reshaped.shape}")

import torch

# Створимо тензор з відстеженням градієнтів
original = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
print(f"Оригінал: {original}")
print(f"requires_grad: {original.requires_grad}\n")

# clone() — повна копія з графом обчислень
cloned = original.clone()
print(f"Після clone(): {cloned}")
print(f"requires_grad: {cloned.requires_grad}")
print(f"Ділять пам'ять? {cloned.data_ptr() == original.data_ptr()}\n")

# detach() — копія БЕЗ графа обчислень
detached = original.detach()
print(f"Після detach(): {detached}")
print(f"requires_grad: {detached.requires_grad}")
print(f"Ділять пам'ять? {detached.data_ptr() == original.data_ptr()}")

import torch

tensor = torch.tensor([1.0, 2.0, 3.0])
print(f"Оригінал: {tensor}")
print(f"ID об'єкта: {id(tensor)}\n")

# Звичайна операція — створює новий тензор
result = tensor.add(10)
print(f"Після add(10): {result}")
print(f"ID нового тензора: {id(result)}")
print(f"Оригінал не змінився: {tensor}\n")

# In-place операція — змінює існуючий тензор
tensor.add_(10)
print(f"Після add_(10): {tensor}")
print(f"ID залишився той самий: {id(tensor)}")

import torch

# Двовимірний тензор (матриця)
matrix = torch.tensor([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
])
print(f"Матриця:\n{matrix}\n")

# Доступ до одного елемента
print(f"Елемент [1, 2]: {matrix[1, 2]}")      # рядок 1, стовпець 2 → 7

# Доступ до рядка
print(f"Другий рядок: {matrix[1]}")           # [5, 6, 7, 8]

# Доступ до стовпця
print(f"Третій стовпець: {matrix[:, 2]}")     # [3, 7, 11]

# Зріз (slicing)
print(f"Підматриця [0:2, 1:3]:\n{matrix[0:2, 1:3]}")

import torch

scores = torch.tensor([45, 78, 92, 34, 88, 67])
print(f"Оцінки: {scores}\n")

# Створення булевої маски
mask = scores >= 70
print(f"Маска (оцінка >= 70): {mask}\n")

# Вибірка елементів за маскою
passed = scores[mask]
print(f"Студенти, які склали: {passed}")

# torch.where() — аналог NumPy np.where
temperatures = torch.tensor([28, 15, 32, 19, 35, 22])

# Якщо температура > 30, повернути "Спека", інакше — "Нормально"
status = torch.where(temperatures > 30, 
                     torch.tensor(1),  # "Спека" 
                     torch.tensor(0))  # "Нормально"

print(f"Температури: {temperatures}")
print(f"Статус (1=Спека, 0=Норм): {status}")

import torch

# Додавання скаляра до вектора
vector = torch.tensor([1, 2, 3, 4])
result = vector + 10

print(f"Вектор: {vector}")
print(f"Вектор + 10: {result}")
print("Broadcasting: скаляр 10 розширюється до [10, 10, 10, 10]")

# Додавання вектора до матриці
matrix = torch.tensor([
    [1, 2, 3],
    [4, 5, 6]
])
vector = torch.tensor([10, 20, 30])

result = matrix + vector
print(f"Матриця (2×3):\n{matrix}\n")
print(f"Вектор (3,): {vector}\n")
print(f"Результат:\n{result}")
print("\nBroadcasting: вектор розширюється до матриці [[10,20,30], [10,20,30]]")

import torch

# Приклад 1: Сумісні форми
a = torch.ones(3, 1)      # форма (3, 1)
b = torch.ones(1, 4)      # форма (1, 4)
result = a + b            # результат (3, 4)

print(f"a форма: {a.shape} → розтягнеться до (3, 4)")
print(f"b форма: {b.shape} → розтягнеться до (3, 4)")
print(f"Результат форма: {result.shape}\n")

# Приклад 2: Несумісні форми (помилка)
try:
    a = torch.ones(3, 2)
    b = torch.ones(3, 3)
    result = a + b
except RuntimeError as e:
    print(f"Помилка: {e}")

import torch

a = torch.tensor([1.0, 2.0, 3.0, 4.0])
b = torch.tensor([10.0, 20.0, 30.0, 40.0])

print(f"a: {a}")
print(f"b: {b}\n")

# Арифметичні операції
print(f"a + b: {a + b}")
print(f"a - b: {a - b}")
print(f"a * b: {a * b}")  # поелементне множення
print(f"a / b: {a / b}")
print(f"a ** 2: {a ** 2}")  # піднесення до степеня

# Математичні функції
x = torch.tensor([0.0, 1.0, 2.0, 3.0])

print(f"exp(x): {torch.exp(x)}")      # e^x
print(f"log(x+1): {torch.log(x+1)}")  # натуральний логарифм
print(f"sqrt(x): {torch.sqrt(x)}")    # квадратний корінь
print(f"sin(x): {torch.sin(x)}")      # синус

import torch

A = torch.tensor([
    [1, 2],
    [3, 4]
])
B = torch.tensor([
    [5, 6],
    [7, 8]
])

print(f"Матриця A:\n{A}\n")
print(f"Матриця B:\n{B}\n")

# Поелементне множення (НЕ матричне!)
print(f"A * B (поелементне):\n{A * B}\n")

# Матричне множення (правильне)
print(f"A @ B (матричне):\n{A @ B}\n")

# Альтернативні способи матричного множення
print(f"torch.matmul(A, B):\n{torch.matmul(A, B)}\n")
print(f"torch.mm(A, B):\n{torch.mm(A, B)}")

import torch

matrix = torch.tensor([
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0]
])

print(f"Матриця:\n{matrix}\n")

# Операції по всьому тензору
print(f"Сума всіх елементів: {matrix.sum()}")
print(f"Середнє всіх елементів: {matrix.mean()}")
print(f"Максимум: {matrix.max()}")
print(f"Мінімум: {matrix.min()}")
print(f"Стандартне відхилення: {matrix.std()}")

# Операції по конкретній вісі
print("Сума по рядках (вісь 0):", matrix.sum(dim=0))
print("Сума по стовпцях (вісь 1):", matrix.sum(dim=1))
print("\nСереднє по рядках:", matrix.mean(dim=0))
print("Середнє по стовпцях:", matrix.mean(dim=1))

# argmax та argmin — повертають ІНДЕКСИ екстремумів
values = torch.tensor([3.2, 1.7, 5.9, 2.4, 4.1])

print(f"Значення: {values}")
print(f"Індекс максимуму: {values.argmax()}")   # 2 (бо values[2] = 5.9)
print(f"Індекс мінімуму: {values.argmin()}")     # 1 (бо values[1] = 1.7)

import torch

# Імітуємо зображення 2×2 пікселі, RGB (3 канали)
# Форма: (height, width, channels)
image = torch.tensor([
    [[255, 0, 128], [200, 50, 100]],
    [[150, 200, 75], [100, 100, 100]]
], dtype=torch.float32)

print(f"Оригінальне зображення [0, 255]:\n{image}\n")
print(f"Форма: {image.shape}")
print(f"Мін: {image.min()}, Макс: {image.max()}\n")

# Нормалізація до [0, 1]
normalized_01 = image / 255.0
print(f"Нормалізація [0, 1]:\n{normalized_01}\n")

# Нормалізація до [-1, 1]
normalized_11 = (image / 255.0) * 2.0 - 1.0
print(f"Нормалізація [-1, 1]:\n{normalized_11}\n")
print(f"Мін: {normalized_11.min():.4f}, Макс: {normalized_11.max():.4f}")

import torch

# Мітки класів для 5 прикладів, 3 класи всього
labels = torch.tensor([0, 2, 1, 0, 2])
num_classes = 3

print(f"Оригінальні мітки: {labels}\n")

# One-hot encoding через torch.nn.functional
import torch.nn.functional as F
one_hot = F.one_hot(labels, num_classes=num_classes)

print(f"One-hot encoding:\n{one_hot}\n")
print(f"Форма: {one_hot.shape}")  # (5, 3) — 5 прикладів, 3 класи

# Альтернативний спосіб через scatter_
labels = torch.tensor([0, 2, 1])
num_classes = 3

one_hot_manual = torch.zeros(labels.size(0), num_classes)
one_hot_manual.scatter_(1, labels.unsqueeze(1), 1)

print(f"One-hot через scatter_:\n{one_hot_manual}")

import torch

# Датасет: 100 прикладів, кожен з 10 ознаками
dataset = torch.randn(100, 10)
print(f"Датасет форма: {dataset.shape}\n")

# Розділення на батчі по 16 прикладів
batch_size = 16
num_batches = len(dataset) // batch_size

for i in range(num_batches):
    start = i * batch_size
    end = start + batch_size
    batch = dataset[start:end]
    print(f"Батч {i+1}: форма {batch.shape}")

import torch

# Імітуємо датасет: 1000 прикладів, 5 ознак
data = torch.randn(1000, 5) * 10 + 50  # середнє ~50, std ~10

print(f"Оригінальні дані:")
print(f"  Форма: {data.shape}")
print(f"  Середнє по ознаках: {data.mean(dim=0)}")
print(f"  Std по ознаках: {data.std(dim=0)}\n")

# Стандартизація: (x - mean) / std
mean = data.mean(dim=0, keepdim=True)
std = data.std(dim=0, keepdim=True)
standardized = (data - mean) / std

print(f"Після стандартизації:")
print(f"  Середнє: {standardized.mean(dim=0)}")
print(f"  Std: {standardized.std(dim=0)}")

import numpy as np

# Функція та її градієнти (обчислені вручну!)
def f(x, y):
    return x**2 + 3*x*y + y**2

def df_dx(x, y):
    return 2*x + 3*y

def df_dy(x, y):
    return 3*x + 2*y

# Обчислення
x, y = 2.0, 3.0
print(f"f({x}, {y}) = {f(x, y)}")
print(f"∂f/∂x = {df_dx(x, y)}")
print(f"∂f/∂y = {df_dy(x, y)}")

import torch

# Створюємо тензори з увімкненим відстеженням градієнтів
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)

# Виконуємо обчислення
z = x**2 + 3*x*y + y**2

print(f"Результат z: {z}")
print(f"Тип z: {type(z)}")
print(f"z.grad_fn: {z.grad_fn}")  # функція, що створила цей тензор

import torch

# Тензори без градієнтів (константи)
a = torch.tensor(5.0)
b = torch.tensor(10.0)

print(f"a.requires_grad: {a.requires_grad}")
print(f"b.requires_grad: {b.requires_grad}\n")

# Операції над тензорами без градієнтів
c = a + b
print(f"c = {c}")
print(f"c.grad_fn: {c.grad_fn}")  # None, бо вхідні тензори не мають градієнтів

# Тензор з увімкненим відстеженням градієнтів
x = torch.tensor(3.0, requires_grad=True)
y = torch.tensor(4.0, requires_grad=True)

# Операції автоматично створюють граф
z = x * y + x**2

print(f"z = {z}")
print(f"z.grad_fn: {z.grad_fn}")
print(f"z.requires_grad: {z.requires_grad}")  # True, бо успадковується

import torch

# Leaf тензори
w = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(3.0, requires_grad=True)

print(f"w.is_leaf: {w.is_leaf}")
print(f"b.is_leaf: {b.is_leaf}\n")

# Проміжні тензори (результати операцій)
x = torch.tensor(5.0)
y = w * x + b  # лінійна модель

print(f"y = {y}")
print(f"y.is_leaf: {y.is_leaf}")
print(f"y.grad_fn: {y.grad_fn}")

import torch

# Створюємо змінні
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)

# Обчислюємо функцію
z = x**2 + 3*x*y + y**2

print(f"z = {z}\n")

# Обчислюємо градієнти автоматично!
z.backward()

print(f"∂z/∂x = {x.grad}")  # має бути 2x + 3y = 2*2 + 3*3 = 13
print(f"∂z/∂y = {y.grad}")  # має бути 3x + 2y = 3*2 + 2*3 = 12

import torch

# Параметри моделі (навчаються)
w = torch.tensor(0.5, requires_grad=True)
b = torch.tensor(0.2, requires_grad=True)

# Вхідні дані (константи)
x = torch.tensor(3.0)
y_true = torch.tensor(2.0)

# Forward pass
y_pred = w * x + b
loss = (y_pred - y_true) ** 2  # MSE для одного прикладу

print(f"Передбачення: {y_pred.item():.4f}")
print(f"Справжнє значення: {y_true.item()}")
print(f"Функція втрат (MSE): {loss.item():.4f}\n")

# Backward pass
loss.backward()

print(f"∂loss/∂w = {w.grad}")
print(f"∂loss/∂b = {b.grad}")

import torch

x = torch.tensor(3.0, requires_grad=True)

# Перший backward
y = x ** 2
y.backward()
print(f"Після першого backward: x.grad = {x.grad}")

# Другий backward (БЕЗ zero_grad!)
y = x ** 2
y.backward()
print(f"Після другого backward: x.grad = {x.grad}")  # 12, а не 6!

# Правильний спосіб: обнуляємо градієнти перед кожним backward
x = torch.tensor(3.0, requires_grad=True)

y = x ** 2
y.backward()
print(f"Перший backward: x.grad = {x.grad}")

x.grad.zero_()  # обнулюємо!
y = x ** 2
y.backward()
print(f"Другий backward (з zero_): x.grad = {x.grad}")

import torch

w = torch.tensor(2.0, requires_grad=True)
x = torch.tensor(3.0)

# З градієнтами (зазвичай для тренування)
y_train = w * x
print(f"Тренування: y = {y_train}")
print(f"y.requires_grad: {y_train.requires_grad}")
print(f"y.grad_fn: {y_train.grad_fn}\n")

# Без градієнтів (для inference)
with torch.no_grad():
    y_inference = w * x
    print(f"Інференс: y = {y_inference}")
    print(f"y.requires_grad: {y_inference.requires_grad}")
    print(f"y.grad_fn: {y_inference.grad_fn}")

import torch

x = torch.tensor(5.0, requires_grad=True)
y = x ** 2

print(f"y = {y}")
print(f"y.requires_grad: {y.requires_grad}\n")

# Відокремлюємо від графа
y_detached = y.detach()
print(f"y_detached = {y_detached}")
print(f"y_detached.requires_grad: {y_detached.requires_grad}")
print(f"y_detached.grad_fn: {y_detached.grad_fn}\n")

# Можна використовувати у подальших обчисленнях без gradients
z = y_detached * 2
print(f"z = y_detached * 2 = {z}")
print(f"z.requires_grad: {z.requires_grad}")

import torch

def compute(x, training=True):
    torch.set_grad_enabled(training)
    y = x ** 2
    return y

x = torch.tensor(3.0, requires_grad=True)

# Режим тренування
result_train = compute(x, training=True)
print(f"Тренування: {result_train}, requires_grad={result_train.requires_grad}")

# Режим інференсу
result_inference = compute(x, training=False)
print(f"Інференс: {result_inference}, requires_grad={result_inference.requires_grad}")