##
Kom godt i gang med PyTorch
Trin 1:Opsætning af miljø
* Installer Python og opret et virtuelt miljø
- Python 3.6 eller højere anbefales.
- Opret et virtuelt miljø ved hjælp af `python -m venv venv` (eller `virtualenv venv` for ældre Python-versioner) og aktiver det med `source venv/bin/activate` på Linux/macOS eller `venv\Scripts\activate` på Windows .
* Installer PyTorch
- Brug `pip` til at installere PyTorch:`pip install torch torchvision`.
- For GPU-understøttelse skal du installere `torch` med `-c pytorch`-indstillingen.
Trin 2:Simpelt eksempel - Oprettelse af en tensor
``` python
import lommelygte
Opret en tensor fra en liste
tensor =torch.tensor([1, 2, 3])
Udskriv tensoren
print (tensor)
Udskriv formen på tensoren
print(tensor.shape)
Udskriv typen af tensor
print(tensor.dtype)
```
Produktion:
```
tensor([1, 2, 3])
fakkel.Størrelse([3])
torch.int64
```
Trin 3:Grundlæggende matematiske handlinger
``` python
Elementmæssig tilføjelse
tensor =torch.tensor([1, 2, 3])
tensor2 =torch.tensor([4, 5, 6])
resultat =tensor + tensor2
print (resultat)
Output:tensor([ 5, 7, 9])
Matrixmultiplikation
matrix1 =torch.tensor([[1, 2], [3, 4]])
matrix2 =torch.tensor([[5, 6], [7, 8]])
resultat =fakkel.mm(matrix1, matrix2)
print (resultat)
Output:tensor([[19, 22], [43, 50]])
```
Trin 4:Brug af GPU til hurtigere beregning
``` python
Tjek, om CUDA er tilgængelig
hvis torch.cuda.is_available():
# Flyt tensorerne til GPU
enhed =torch.device("cuda")
tensor =tensor.to(enhed)
tensor2 =tensor2.to(enhed)
# Udfør operationer på GPU
resultat =tensor + tensor2
# Flyt resultatet tilbage til CPU, hvis det er nødvendigt
resultat =result.to("cpu")
print (resultat)
```
Arbejde med data
Trin 1:Datasæt
PyTorch giver en bekvem måde at arbejde med datasæt ved at bruge sin 'Dataset'-klasse. Her er et eksempel:
``` python
klasse MyDataset(torch.utils.data.Dataset):
def __init__(selv, data, etiketter):
selv.data =data
self.labels =labels
def __getitem__(selv, indeks):
returner self.data[indeks], self.labels[indeks]
def __len__(selv):
return len(selv.data)
Opret en forekomst af datasættet
datasæt =Mit Datasæt(data, etiketter)
```
Trin 2:DataLoader
Brug `DataLoader` til effektivt at indlæse data i batches under træning.
``` python
Definer batchstørrelse
batch_size =32
Opret en dataindlæser
data_loader =torch.utils.data.DataLoader(datasæt, batch_size=batch_size)
Generer gennem batcherne
for batch i data_loader:
# Her ville batch være en tuple af `(data, etiketter)`
```
Opbygning af et neuralt netværk
Trin 1:Initialiser dit netværk
``` python
import fakkel.nn som nn
Definer et simpelt neuralt netværk med 3 lag
klasse MyNeuralNetwork(nn.Module):
def __init__(selv):
super(MyNeuralNetwork, self).__init__()
self.layer1 =nn.Linear(784, 256) # Inputlag
self.layer2 =nn.Linear(256, 128) # Skjult lag
self.layer3 =nn.Linear(128, 10) # Outputlag
def forward(selv, x):
x =x.view(x.shape[0], -1) # Flad input
x =F.relu(selv.lag1(x)) # Aktiveringsfunktion (ReLU)
x =F.relu(selv.lag2(x)) # Aktiveringsfunktion (ReLU)
x =F.log_softmax(self.layer3(x)) # Outputlag med softmax
retur x
Initialiser netværket
netværk =MyNeuralNetwork()
```
Trin 2:Definer tabsfunktion og optimering
``` python
importer torch.optim som optim
Definer tabsfunktion (her bruger vi krydsentropitab)
loss_fn =nn.CrossEntropyLoss()
Definer optimizer (her bruger vi stokastisk gradientnedstigning)
optimizer =optim.SGD(netværk.parametre(), lr=0,001)
```
Trin 3:Træn netværket
``` python
Træn netværket i 10 epoker
for epoke i rækkevidde(10):
for batch i data_loader:
# Få input og etiketter
input, labels =batch
# Klare gradienter
optimizer.zero_grad()
# Fremadgående pass
udgange =netværk (indgange)
# Beregningstab
tab =tab_fn(output, etiketter)
# Baglæns pass og opdater vægte
loss.backward()
optimizer.step()
print(f"Epoke {epoke + 1}:Tab:{loss.item()}")
```
Trin 4:Evaluer netværket
``` python
Evaluer netværkets nøjagtighed på testdatasættet
med torch.no_grad():
korrekt =0
i alt =0
for batch i test_data_loader:
input, labels =batch
# Fremadgående pass
udgange =netværk (indgange)
# Få forudsigelser
_, forudsagt =torch.max(outputs.data, 1)
# Opdater nøjagtighedstælling
i alt +=labels.size(0)
korrekt +=(forudsagt ==etiketter).sum().item()
# Beregn nøjagtighed
nøjagtighed =korrekt / total
print(f"Nøjagtighed på testdata:{nøjagtighed * 100}%")
```
