Stap 1:Omgeving instellen

* Installeer Python en creëer een virtuele omgeving

- Python 3.6 of hoger wordt aanbevolen.

- Creëer een virtuele omgeving met `python -m venv venv` (of `virtualenv venv` voor oudere Python-versies) en activeer deze met `source venv/bin/activate` op Linux/macOS of `venv\Scripts\activate` op Windows .

* PyTorch installeren

- Gebruik `pip` om PyTorch te installeren:`pip install torch torchvision`.

- Voor GPU-ondersteuning installeert u `torch` met de optie `-c pytorch`.

Stap 2:Eenvoudig voorbeeld - Een tensor maken

```python

fakkel importeren

Maak een tensor uit een lijst

tensor =fakkel.tensor([1, 2, 3])

Print de tensor

afdrukken(tensor)

Print de vorm van de tensor

print(tensorvorm)

Print het type van de tensor

print(tensor.dtype)

```

Uitgang:

```

tensor([1, 2, 3])

fakkel. Grootte ([3])

fakkel.int64

```

Stap 3:Basis wiskundige bewerkingen

```python

Elementgewijze optelling

tensor =fakkel.tensor([1, 2, 3])

tensor2 =fakkel.tensor([4, 5, 6])

resultaat =tensor + tensor2

afdrukken(resultaat)

Uitvoer:tensor([ 5, 7, 9])

Matrixvermenigvuldiging

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

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

resultaat =fakkel.mm(matrix1, matrix2)

afdrukken(resultaat)

Uitvoer:tensor([[19, 22], [43, 50]])

```

Stap 4:GPU gebruiken voor snellere berekeningen

```python

Controleer of CUDA beschikbaar is

als fakkel.cuda.is_available():

# Verplaats de tensoren naar GPU

apparaat =fakkel.apparaat("cuda")

tensor =tensor.to(apparaat)

tensor2 =tensor2.to(apparaat)

# Voer bewerkingen uit op GPU

resultaat =tensor + tensor2

# Verplaats het resultaat indien nodig terug naar de CPU

resultaat =resultaat.to("cpu")

afdrukken(resultaat)

```

Werken met gegevens

Stap 1:Gegevensset

PyTorch biedt een handige manier om met datasets te werken met behulp van de `Dataset`-klasse. Hier is een voorbeeld:

```python

klasse MijnDataset(torch.utils.data.Dataset):

def __init__(zelf, gegevens, labels):

zelf.data =gegevens

self.labels =labels

def __getitem__(zelf, index):

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

def __len__(zelf):

retourneer len(self.data)

Maak een instantie van de dataset

dataset =MijnDataset(gegevens, labels)

```

Stap 2:DataLoader

Gebruik `DataLoader` om tijdens de training gegevens efficiënt in batches te laden.

```python

Definieer de batchgrootte

batch_grootte =32

Maak een gegevenslader

data_loader =torch.utils.data.DataLoader(dataset, batch_size=batch_size)

Doorloop de batches

voor batch in data_loader:

# Hier zou batch een tupel van `(data, labels)` zijn

```

Een neuraal netwerk opbouwen

Stap 1:Initialiseer uw netwerk

```python

importeer fakkel.nn als nn

Definieer een eenvoudig neuraal netwerk met 3 lagen

klasse MijnNeuralNetwerk(nn.Module):

def __init__(zelf):

super(MijnNeuralNetwerk, zelf).__init__()

self.layer1 =nn.Linear(784, 256) # Invoerlaag

self.layer2 =nn.Linear(256, 128) # Verborgen laag

self.layer3 =nn.Linear(128, 10) # Uitvoerlaag

zeker vooruit(zelf, x):

x =x.view(x.shape[0], -1) # Maak de invoer plat

x =F.relu(self.layer1(x)) # Activeringsfunctie (ReLU)

x =F.relu(self.layer2(x)) # Activeringsfunctie (ReLU)

x =F.log_softmax(self.layer3(x)) # Uitvoerlaag met softmax

retour x

Initialiseer het netwerk

netwerk =MijnNeuralNetwerk()

```

Stap 2:Definieer de verliesfunctie en optimalisatie

```python

importeer torch.optim als optim

Definieer de verliesfunctie (hier gebruiken we cross-entropieverlies)

loss_fn =nn.CrossEntropyLoss()

Definieer de optimalisatie (hier gebruiken we stochastische gradiëntafdaling)

optimizer =optim.SGD(netwerk.parameters(), lr=0,001)

```

Stap 3:Train het netwerk

```python

Train het netwerk gedurende 10 tijdperken

voor tijdperk binnen bereik(10):

voor batch in data_loader:

# Ontvang invoer en labels

ingangen, labels =batch

# Duidelijke verlopen

optimizer.zero_grad()

# Voorwaartse pass

uitgangen =netwerk(ingangen)

# Bereken verlies

verlies =loss_fn(uitgangen, labels)

# Achterwaarts doorgeven en gewichten bijwerken

verlies.achteruit()

optimizer.step()

print(f"Epoche {epoch + 1}:Verlies:{loss.item()}")

```

Stap 4:Evalueer het netwerk

```python

Evalueer de netwerknauwkeurigheid van de testdataset

met fakkel.no_grad():

juist =0

totaal =0

voor batch in test_data_loader:

ingangen, labels =batch

# Voorwaartse pas

uitgangen =netwerk(ingangen)

# Ontvang voorspellingen

_, voorspeld =fakkel.max(outputs.data, 1)

# Update nauwkeurigheidtelling

totaal +=labels.size(0)

correct +=(voorspelde ==labels).sum().item()

# Bereken nauwkeurigheid

nauwkeurigheid =correct / totaal

print(f"Nauwkeurigheid van testgegevens:{nauwkeurigheid * 100}%")

```