Come utilizzare PyTorch in Python [Tutorial completo]

## Iniziare con PyTorch

Passaggio 1:configurazione dell'ambiente

* Installa Python e crea un ambiente virtuale

- Si consiglia Python 3.6 o versione successiva.

- Crea un ambiente virtuale utilizzando `python -m venv venv` (o `virtualenv venv` per versioni Python precedenti) e attivalo con `source venv/bin/activate` su Linux/macOS o `venv\Scripts\activate` su Windows .

* Installa PyTorch

- Usa `pip` per installare PyTorch:`pip install torch torchvision`.

- Per il supporto GPU, installa `torch` con l'opzione `-c pytorch`.

Passaggio 2:semplice esempio:creazione di un tensore

```pitone

torcia di importazione

Crea un tensore da una lista

tensore =torcia.tensore([1, 2, 3])

Stampa il tensore

stampa(tensore)

Stampa la forma del tensore

print(tensore.forma)

Stampa il tipo del tensore

print(tensore.dtipo)

```

Produzione:

```

tensore([1, 2, 3])

torcia.Dimensione([3])

torcia.int64

```

Passaggio 3:operazioni matematiche di base

```pitone

Aggiunta per elemento

tensore =torcia.tensore([1, 2, 3])

tensore2 =torcia.tensore([4, 5, 6])

risultato =tensore + tensore2

stampa(risultato)

Risultato:tensore([ 5, 7, 9])

Moltiplicazione di matrici

matrice1 =torcia.tensore([[1, 2], [3, 4]])

matrice2 =torcia.tensore([[5, 6], [7, 8]])

risultato =torcia.mm(matrice1, matrice2)

stampa(risultato)

Risultato:tensore([[19, 22], [43, 50]])

```

Passaggio 4:utilizzo della GPU per calcoli più rapidi

```pitone

Controlla se CUDA è disponibile

se torch.cuda.is_available():

# Sposta i tensori sulla GPU

dispositivo =torcia.dispositivo("cuda")

tensore =tensore.to(dispositivo)

tensore2 =tensore2.to(dispositivo)

# Esegui operazioni sulla GPU

risultato =tensore + tensore2

# Se necessario, sposta nuovamente il risultato sulla CPU

risultato =risultato.to("cpu")

stampa(risultato)

```

Lavorare con i dati

Passaggio 1:set di dati

PyTorch fornisce un modo conveniente per lavorare con i set di dati utilizzando la sua classe "Dataset". Ecco un esempio:

```pitone

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

def __init__(self, dati, etichette):

self.dati =dati

self.labels =etichette

def __getitem__(self, indice):

return self.dati[indice], self.etichette[indice]

def __len__(self):

return len(self.data)

Crea un'istanza del set di dati

set di dati =MyDataset(dati, etichette)

```

Passaggio 2:DataLoader

Utilizza "DataLoader" per caricare in modo efficiente i dati in batch durante l'addestramento.

```pitone

Definisci la dimensione del batch

dimensione_lotto =32

Crea un caricatore dati

data_loader =torch.utils.data.DataLoader(set di dati, batch_size=batch_size)

Itera attraverso i batch

per batch in data_loader:

# Qui batch sarebbe una tupla di `(dati, etichette)`

```

Costruire una rete neurale

Passaggio 1:inizializza la tua rete

```pitone

importa torch.nn come nn

Definisci una rete neurale semplice con 3 livelli

classe MyNeuralNetwork(nn.Module):

def __init__(self):

super(MyNeuralNetwork, self).__init__()

self.layer1 =nn.Linear(784, 256) # Livello di input

self.layer2 =nn.Linear(256, 128) # Livello nascosto

self.layer3 =nn.Linear(128, 10) # Livello di output

def avanti(self, x):

x =x.view(x.shape[0], -1) # Appiattisce l'input

x =F.relu(self.layer1(x)) # Funzione di attivazione (ReLU)

x =F.relu(self.layer2(x)) # Funzione di attivazione (ReLU)

x =F.log_softmax(self.layer3(x)) # Livello di output con softmax

restituire x

Inizializza la rete

rete =La mia rete neurale()

```

Passaggio 2:definire la funzione di perdita e l'ottimizzatore

```pitone

importa torch.optim come ottimale

Definisci la funzione di perdita (qui usiamo la perdita di entropia incrociata)

perdita_fn =nn.CrossEntropyLoss()

Definisci l'ottimizzatore (qui utilizziamo la discesa del gradiente stocastico)

ottimizzatore =optim.SGD(network.parameters(), lr=0.001)

```

Passaggio 3:forma la rete

```pitone

Addestra la rete per 10 epoche

per l'epoca nell'intervallo(10):

per batch in data_loader:

# Ottieni input ed etichette

input, etichette =lotto

# Cancella gradienti

ottimizzatore.zero_grad()

# Passaggio in avanti

uscite =rete(ingressi)

# Perdita di calcolo

perdita =perdita_fn(uscite, etichette)

# Passaggio all'indietro e aggiornamento dei pesi

perdita.indietro()

ottimizzatore.passo()

print(f"Epoca {epoca + 1}:Perdita:{loss.item()}")

```

Passaggio 4:valuta la rete

```pitone

Valuta la precisione della rete sul set di dati di test

con torch.no_grad():

corretto =0

totale =0

per batch in test_data_loader:

input, etichette =lotto

# Passaggio in avanti

uscite =rete(ingressi)

# Ottieni previsioni

_, previsto =torcia.max(outputs.data, 1)

# Aggiorna il conteggio della precisione

totale +=etichette.dimensione(0)

corretto +=(previsto ==etichette).sum().item()

# Calcola la precisione

precisione =corretta/totale

print(f"Precisione sui dati del test:{precisione * 100}%")

```

• Come installare Python su Ubuntu 
• Come utilizzare TensorFlow in Python [Tutorial completo]