Версия Python

!python -V

Python 3.12.6

Импорт необходимых библиотек

# Подавление предупреждений
import warnings
for warn in [UserWarning, FutureWarning]: warnings.filterwarnings("ignore", category = warn)

import os
import numpy as np
import torch
import torch.nn as nn
import pandas as pd
import jupyterlab as jlab

from dataclasses import dataclass

Версии необходимых библиотек

packages = [
    "Torch", "NumPy", "Pandas", "JupyterLab",
]

package_objects = [
    torch, np, pd, jlab
]

versions = list(map(lambda obj: obj.__version__, package_objects))

pkgs = {"Библиотека": packages, "Версия": versions}
df_pkgs = pd.DataFrame(data = pkgs)
df_pkgs.index.name = "№"
df_pkgs.index += 1

display(df_pkgs)

path_to_reqs = "."
reqs_name = "requirements.txt"

def get_packages_and_versions():
    """Генерация строк с библиотеками и их версиями в формате: библиотека==версия"""
    
    for package, version in zip(packages, versions):
        yield f"{package.lower()}=={version}\n"

with open(os.path.join(path_to_reqs, reqs_name), "w", encoding = "utf-8") as f:
    f.writelines(get_packages_and_versions())

	Библиотека	Версия
№
1	Torch	2.2.2
2	NumPy	1.26.4
3	Pandas	2.2.3
4	JupyterLab	4.2.5

Пример однослойной нейросети

@dataclass
class SLNN(nn.Module):
    input_size: int # Входной слой
    hidden_size: int # Скрытый слой
    output_size: int # Выходной слой

    # Вызывается сразу после __init__ при использовании dataclass
    def __post_init__(self):
        super(SLNN, self).__init__()

        # Определение скрытого слоя
        self.hidden = nn.Linear(self.input_size, self.hidden_size)
        # Определение выходного слоя
        self.output = nn.Linear(self.hidden_size, self.output_size)

        # Определение функции активации для скрытого слоя
        self.g = nn.ReLU()

    # Прямой проход данных через нейросеть
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Проход через скрытый слой с функцией активации
        x = self.g(self.hidden(x))
        # Проход через выходной слой
        x = self.output(x)

        return x

# Проверка наличия GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Создание экземпляра модели
model = SLNN(input_size = 10, hidden_size = 20, output_size = 5).to(device)

# Генерация случайного тензора
input = torch.randn(2, model.input_size).to(device)

# Проход через модель
output = model(input)

# Вывод результирующего тензора после прохождения через модель
print("Результирующий тензор после прохождения через модель:")
print(output)

# Вывод размера результирующего тензора
print("Размер результирующего тензора:")
print(output.size())

Результирующий тензор после прохождения через модель:
tensor([[-0.0664,  0.4826,  0.2557,  0.1663,  0.0823],
        [-0.1112, -0.0267,  0.2637, -0.2801,  0.0210]],
       grad_fn=<AddmmBackward0>)
Размер результирующего тензора:
torch.Size([2, 5])