##
Komma igång med PyTorch
Steg 1:Konfigurera miljö
* Installera Python och skapa en virtuell miljö
- Python 3.6 eller högre rekommenderas.
- Skapa en virtuell miljö med `python -m venv venv` (eller `virtualenv venv` för äldre Python-versioner) och aktivera den med `source venv/bin/activate` på Linux/macOS eller `venv\Scripts\activate` på Windows .
* Installera PyTorch
- Använd `pip` för att installera PyTorch:`pip install torch torchvision`.
- För GPU-stöd, installera "torch" med alternativet "-c pytorch".
Steg 2:Enkelt exempel – Skapa en tensor
``` python
importera ficklampa
Skapa en tensor från en lista
tensor =torch.tensor([1, 2, 3])
Skriv ut tensorn
print (tensor)
Skriv ut formen på tensorn
print(tensor.shape)
Skriv ut typen av tensor
print(tensor.dtype)
```
Produktion:
```
tensor([1, 2, 3])
ficklampa.Size([3])
torch.int64
```
Steg 3:Grundläggande matematikoperationer
``` python
Elementvis tillägg
tensor =torch.tensor([1, 2, 3])
tensor2 =torch.tensor([4, 5, 6])
resultat =tensor + tensor2
print (resultat)
Utdata:tensor([ 5, 7, 9])
Matrismultiplikation
matrix1 =torch.tensor([[1, 2], [3, 4]])
matrix2 =torch.tensor([[5, 6], [7, 8]])
resultat =ficklampa.mm(matris1, matris2)
print (resultat)
Utdata:tensor([[19, 22], [43, 50]])
```
Steg 4:Använd GPU för snabbare beräkning
``` python
Kontrollera om CUDA är tillgängligt
om torch.cuda.is_available():
# Flytta tensorerna till GPU
device =torch.device("cuda")
tensor =tensor.to(enhet)
tensor2 =tensor2.to(enhet)
# Utför operationer på GPU
resultat =tensor + tensor2
# Flytta tillbaka resultatet till CPU om det behövs
resultat =result.to("cpu")
print (resultat)
```
Arbeta med data
Steg 1:Datauppsättning
PyTorch tillhandahåller ett bekvämt sätt att arbeta med datauppsättningar genom att använda sin "Dataset"-klass. Här är ett exempel:
``` python
klass MyDataset(torch.utils.data.Dataset):
def __init__(själv, data, etiketter):
self.data =data
self.labels =etiketter
def __getitem__(själv, index):
returnera self.data[index], self.labels[index]
def __len__(själv):
return len(self.data)
Skapa en instans av datasetet
dataset =MyDataset(data, etiketter)
```
Steg 2:DataLoader
Använd `DataLoader` för att effektivt ladda data i omgångar under träning.
``` python
Definiera batchstorlek
batch_size =32
Skapa en dataladdare
data_loader =torch.utils.data.DataLoader(dataset, batch_size=batch_size)
Iterera genom satserna
för batch i data_loader:
# Här skulle batch vara en tuppel av `(data, etiketter)`
```
Bygga ett neuralt nätverk
Steg 1:Initiera ditt nätverk
``` python
importera torch.nn som nn
Definiera ett enkelt neuralt nätverk med 3 lager
klass MyNeuralNetwork(nn.Module):
def __init__(själv):
super(MyNeuralNetwork, self).__init__()
self.layer1 =nn.Linear(784, 256) # Indatalager
self.layer2 =nn.Linear(256, 128) # Dolt lager
self.layer3 =nn.Linear(128, 10) # Utdatalager
def forward(själv, x):
x =x.view(x.shape[0], -1) # Platta ingång
x =F.relu(self.layer1(x)) # Aktiveringsfunktion (ReLU)
x =F.relu(self.layer2(x)) # Aktiveringsfunktion (ReLU)
x =F.log_softmax(self.layer3(x)) # Utdatalager med softmax
tillbaka x
Initiera nätverket
nätverk =MyNeuralNetwork()
```
Steg 2:Definiera förlustfunktion och optimering
``` python
importera torch.optim som optim
Definiera förlustfunktion (här använder vi korsentropiförlust)
loss_fn =nn.CrossEntropyLoss()
Definiera optimerare (här använder vi stokastisk gradientnedstigning)
optimizer =optim.SGD(nätverk.parameters(), lr=0,001)
```
Steg 3:Träna nätverket
``` python
Träna nätverket i 10 epoker
för epok inom intervall(10):
för batch i data_loader:
# Få indata och etiketter
ingångar, etiketter =batch
# Tydliga övertoningar
optimizer.zero_grad()
# Framåtpassning
utgångar =nätverk (ingångar)
# Beräkningsförlust
förlust =förlust_fn(utgångar, etiketter)
# Passa bakåt och uppdatera vikter
loss.backward()
optimizer.step()
print(f"Epok {epok + 1}:Förlust:{loss.item()}")
```
Steg 4:Utvärdera nätverket
``` python
Utvärdera nätverksnoggrannheten på testdatauppsättningen
med torch.no_grad():
korrekt =0
totalt =0
för batch i test_data_loader:
ingångar, etiketter =batch
# Framåtpassning
utgångar =nätverk (ingångar)
# Få förutsägelser
_, predicted =torch.max(outputs.data, 1)
# Uppdatera noggrannhetsräkning
totalt +=labels.size(0)
korrekt +=(förutsagt ==etiketter).sum().item()
# Beräkna noggrannhet
noggrannhet =korrekt / totalt
print(f"Noggrannhet på testdata:{noggrannhet * 100}%")
```
