Ako používať PyTorch v Pythone [Kompletný návod]

## Začíname s PyTorch

Krok 1:Nastavenie prostredia

* Nainštalujte Python a vytvorte virtuálne prostredie

- Odporúča sa Python 3.6 alebo vyšší.

- Vytvorte virtuálne prostredie pomocou `python -m venv venv` (alebo `virtualenv venv` pre staršie verzie Pythonu) a aktivujte ho pomocou `source venv/bin/activate` v systéme Linux/macOS alebo `venv\Scripts\activate` v systéme Windows .

* Nainštalujte PyTorch

- Na inštaláciu PyTorch použite `pip`:`pip install torch torchvision`.

- Pre podporu GPU nainštalujte `torch` s voľbou `-c pytorch`.

Krok 2:Jednoduchý príklad – Vytvorenie tenzora

```pytón

dovozová baterka

Vytvorte tenzor zo zoznamu

tenzor =pochodeň.tensor([1, 2, 3])

Vytlačte tenzor

tlač (tensor)

Vytlačte tvar tenzora

print(tensor.shape)

Vytlačte typ tenzora

print(tensor.dtype)

```

výstup:

```

tenzor([1, 2, 3])

baterka.Veľkosť([3])

pochodeň.int64

```

Krok 3:Základné matematické operácie

```pytón

Pridávanie prvkov

tenzor =pochodeň.tensor([1, 2, 3])

tenzor2 =pochodeň.tensor([4, 5, 6])

výsledok =tenzor + tenzor2

vytlačiť (výsledok)

Výstup:tensor([ 5, 7, 9])

Násobenie matice

matrix1 =pochodeň.tensor([[1, 2], [3, 4]])

matrix2 =pochodeň.tensor([[5, 6], [7, 8]])

výsledok =pochodeň.mm(matica1, matica2)

vytlačiť (výsledok)

Výstup:tenzor([[19, 22], [43, 50]])

```

Krok 4:Použitie GPU na rýchlejší výpočet

```pytón

Skontrolujte, či je k dispozícii CUDA

if torch.cuda.is_available():

# Presuňte tenzory na GPU

zariadenie =torch.device("cuda")

tenzor =tenzor.k (zariadeniu)

tensor2 =tensor2.to(zariadenie)

# Vykonávať operácie na GPU

výsledok =tenzor + tenzor2

# V prípade potreby presuňte výsledok späť do CPU

vysledok =vysledok.to("cpu")

vytlačiť (výsledok)

```

Práca s údajmi

Krok 1:Množina údajov

PyTorch poskytuje pohodlný spôsob práce so súbormi údajov pomocou svojej triedy `Dataset`. Tu je príklad:

```pytón

trieda MyDataset(torch.utils.data.Dataset):

def __init__(vlastné, údaje, štítky):

self.data =dáta

self.labels =štítky

def __getitem__(vlastné, index):

return self.data[index], self.labels[index]

def __len__(self):

return len(self.data)

Vytvorte inštanciu množiny údajov

dataset =MyDataset(data, labels)

```

Krok 2:DataLoader

Použite `DataLoader` na efektívne načítanie dát v dávkach počas tréningu.

```pytón

Definujte veľkosť dávky

veľkosť_dávky =32

Vytvorte nástroj na načítanie údajov

data_loader =torch.utils.data.DataLoader(množina údajov, veľkosť_dávky=veľkosť_dávky)

Opakujte jednotlivé dávky

pre dávku v data_loader:

# Tu by dávka bola n-ticou `(údaje, štítky)`

```

Vybudovanie neurónovej siete

Krok 1:Inicializujte sieť

```pytón

importovať pochodeň.nn ako nn

Definujte jednoduchú neurónovú sieť s 3 vrstvami

trieda MyNeuralNetwork(nn.Modul):

def __init__(self):

super(MyNeuralNetwork, self).__init__()

self.layer1 =nn.Linear(784, 256) # Vstupná vrstva

self.layer2 =nn.Linear(256, 128) # Skrytá vrstva

self.layer3 =nn.Linear(128, 10) # Výstupná vrstva

def forward(self, x):

x =x.view(x.shape[0], -1) # Vyrovnať vstup

x =F.relu(self.layer1(x)) # Aktivačná funkcia (ReLU)

x =F.relu(self.layer2(x)) # Aktivačná funkcia (ReLU)

x =F.log_softmax(self.layer3(x)) # Výstupná vrstva so softmax

vrátiť x

Inicializujte sieť

sieť =MyNeuralNetwork()

```

Krok 2:Definujte stratovú funkciu a optimalizátor

```pytón

importovať baterku.optim ako optim

Definujte stratovú funkciu (tu používame stratu krížovej entropie)

strata_fn =nn.CrossEntropyLoss()

Definujte optimalizátor (tu používame stochastický gradient zostup)

optimalizátor =optim.SGD(network.parameters(), lr=0,001)

```

Krok 3:Trénujte sieť

```pytón

Trénujte sieť na 10 epoch

pre epochu v rozsahu (10):

pre dávku v data_loader:

# Získajte vstupy a štítky

vstupy, štítky =dávka

# Jasné prechody

optimalizátor.zero_grad()

# Prihrávka dopredu

výstupy =sieť (vstupy)

# Výpočet straty

strata =strata_fn(výstupy, štítky)

# Spätný prechod a aktualizácia hmotnosti

strata.dozadu()

optimalizátor.krok()

print(f"Epocha {epocha + 1}:Strata:{loss.item()}")

```

Krok 4:Vyhodnoťte sieť

```pytón

Vyhodnoťte presnosť siete na testovacej množine údajov

s torch.no_grad():

správne =0

celkom =0

pre dávku v test_data_loader:

vstupy, štítky =dávka

# Prihrávka dopredu

výstupy =sieť (vstupy)

# Získajte predpovede

_, predpokladané =pochodeň.max(výstupy.údaje, 1)

# Aktualizujte počet presnosti

celkove +=labels.size(0)

správne +=(predpokladané ==štítky).sum().item()

# Vypočítajte presnosť

presnosť =správna / celková

print(f"Presnosť testovacích údajov:{presnosť * 100}%")

```

• Predchádzajúca strana: Ako nainštalovať Python v Ubuntu 
• Ďalšia strana: Ako používať TensorFlow v Pythone [Kompletný návod]