##
Komme i gang med PyTorch
Trinn 1:Miljøoppsett
* Installer Python og lag et virtuelt miljø
- Python 3.6 eller høyere anbefales.
- Lag et virtuelt miljø ved å bruke `python -m venv venv` (eller `virtualenv venv` for eldre Python-versjoner) og aktiver det med `source venv/bin/activate` på Linux/macOS eller `venv\Scripts\activate` på Windows .
* Installer PyTorch
- Bruk `pip` for å installere PyTorch:`pip install torch torchvision`.
- For GPU-støtte, installer `torch` med `-c pytorch`-alternativet.
Trinn 2:Enkelt eksempel – Opprette en tensor
``` python
importere lommelykt
Lag en tensor fra en liste
tensor =torch.tensor([1, 2, 3])
Skriv ut tensoren
print (tensor)
Skriv ut formen til tensoren
print(tensor.shape)
Skriv ut typen tensor
print(tensor.dtype)
```
Produksjon:
```
tensor([1, 2, 3])
fakkel.Størrelse([3])
torch.int64
```
Trinn 3:Grunnleggende matematiske operasjoner
``` python
Elementmessig tillegg
tensor =torch.tensor([1, 2, 3])
tensor2 =torch.tensor([4, 5, 6])
resultat =tensor + tensor2
print (resultat)
Utgang:tensor([ 5, 7, 9])
Matrisemultiplikasjon
matrise1 =torch.tensor([[1, 2], [3, 4]])
matrise2 =torch.tensor([[5, 6], [7, 8]])
resultat =fakkel.mm(matrise1, matrise2)
print (resultat)
Utgang:tensor([[19, 22], [43, 50]])
```
Trinn 4:Bruk av GPU for raskere beregning
``` python
Sjekk om CUDA er tilgjengelig
if torch.cuda.is_available():
# Flytt tensorene til GPU
device =torch.device("cuda")
tensor =tensor.to(enhet)
tensor2 =tensor2.to(enhet)
# Utfør operasjoner på GPU
resultat =tensor + tensor2
# Flytt resultatet tilbake til CPU om nødvendig
resultat =result.to("cpu")
print (resultat)
```
Arbeid med data
Trinn 1:Datasett
PyTorch gir en praktisk måte å jobbe med datasett ved å bruke sin `Dataset`-klasse. Her er et eksempel:
``` python
klasse MyDataset(torch.utils.data.Dataset):
def __init__(selv, data, etiketter):
self.data =data
self.labels =etiketter
def __getitem__(selv, indeks):
returner self.data[indeks], self.labels[indeks]
def __len__(selv):
return len(selv.data)
Opprett en forekomst av datasettet
datasett =MyDataset(data, etiketter)
```
Trinn 2:DataLoader
Bruk `DataLoader` for å effektivt laste data i grupper under trening.
``` python
Definer batchstørrelse
batch_size =32
Opprett en datalaster
data_loader =torch.utils.data.DataLoader(datasett, batch_size=batch_size)
Iterer gjennom batchene
for batch i data_loader:
# Her vil batch være en tuppel av `(data, etiketter)`
```
Bygge et nevralt nettverk
Trinn 1:Initialiser nettverket ditt
``` python
import fakkel.nn som nn
Definer et enkelt nevralt nettverk med 3 lag
klasse MyNeuralNetwork(nn.Module):
def __init__(selv):
super(MyNeuralNetwork, self).__init__()
self.layer1 =nn.Linear(784, 256) # Input layer
self.layer2 =nn.Linear(256, 128) # Skjult lag
self.layer3 =nn.Linear(128, 10) # Utgangslag
def forward(selv, x):
x =x.view(x.shape[0], -1) # Flatt input
x =F.relu(selv.lag1(x)) # Aktiveringsfunksjon (ReLU)
x =F.relu(selv.lag2(x)) # Aktiveringsfunksjon (ReLU)
x =F.log_softmax(self.layer3(x)) # Utgangslag med softmax
returnere x
Initialiser nettverket
nettverk =MyNeuralNetwork()
```
Trinn 2:Definer tapsfunksjon og optimalisering
``` python
importer torch.optim som optim
Definer tapsfunksjon (her bruker vi kryssentropitap)
loss_fn =nn.CrossEntropyLoss()
Definer optimizer (her bruker vi stokastisk gradientnedstigning)
optimizer =optim.SGD(nettverk.parametere(), lr=0,001)
```
Trinn 3:Tren nettverket
``` python
Tren nettverket i 10 epoker
for epoke i rekkevidde(10):
for batch i data_loader:
# Få inndata og etiketter
innganger, etiketter =batch
# Tydelige gradienter
optimizer.zero_grad()
# Fremoverpasning
utganger =nettverk (innganger)
# Beregningstap
tap =tap_fn(utganger, etiketter)
# Bakoverpass og oppdater vekter
loss.backward()
optimizer.step()
print(f"Epoke {epoke + 1}:Tap:{loss.item()}")
```
Trinn 4:Evaluer nettverket
``` python
Vurder nettverksnøyaktigheten på testdatasettet
med torch.no_grad():
riktig =0
totalt =0
for batch i test_data_loader:
innganger, etiketter =batch
# Fremoverpasning
utganger =nettverk (innganger)
# Få spådommer
_, predikert =torch.max(outputs.data, 1)
# Oppdater nøyaktighettelling
totalt +=labels.size(0)
korrekt +=(spådd ==etiketter).sum().item()
# Beregn nøyaktighet
nøyaktighet =riktig / totalt
print(f"Nøyaktighet på testdata:{nøyaktighet * 100}%")
```
