Lär Er AI med Python · Lektion

Bygga och träna CNN-modeller i PyTorch

nn.Conv2d, nn.MaxPool2d, nn.Linear, träningsloop, optimerare, förlust, uppföljning av träffsäkerhet.

Lektion 3 av 413 steg

Bygga och träna CNN-modeller i PyTorch är en gratis lektion i Lär Er AI med Python på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär Er AI med Python, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Varför CNN för bilder?

Konvolutionella neurala nätverk lär sig spatiala mönster: kanter, texturer och sedan former och objekt. Konvolutioner delar vikter över hela bilden, vilket gör CNN effektiva och medvetna om förskjutningar – en grundpelare inom datorseende.

import torch
import torch.nn as nn

Basklassen nn.Module

Modeller ärver från nn.Module. Ni definierar lager i __init__ och dataflödet i forward. PyTorch spårar automatiskt parametrar och gradienter.

class CNN(nn.Module):
    def __init__(self):
        super().__init__()

Konvolutionslager

nn.Conv2d(in_channels, out_channels, kernel_size) flyttar inlärningsbara filter över bilden för att skapa egenskapskartor. Den första konvolutionen tar emot 3 kanaler (RGB) och matar ut fler kanaler som fångar olika egenskaper.

self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)

Poolningslager

nn.MaxPool2d nedsamplar egenskapskartor genom att behålla det största värdet i varje fönster. Detta minskar den spatiala storleken, reducerar beräkningarna och ger viss förskjutningsinvarians.

self.pool = nn.MaxPool2d(kernel_size=2, stride=2)

Fullt kopplade lager

Efter konvolutionerna plattar ni ut egenskaperna och skickar dem genom nn.Linear-lager för att skapa klasspoäng. Det sista Linear-lagret matar ut ett värde per klass.

self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.fc2 = nn.Linear(128, 10)  # 10 classes

Metoden forward

Metoden forward definierar hur data flödar: konvolution till ReLU till pooling, upprepat, och sedan utplattning följt av de linjära lagren. F.relu tillför den icke-linjäritet som gör att nätverket kan lära sig komplexa mönster.

import torch.nn.functional as F

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(x.size(0), -1)  # flatten
        x = F.relu(self.fc1(x))
        return self.fc2(x)

Förlust och optimerare

Använd CrossEntropyLoss för klassificering. En optimerare som Adam uppdaterar vikterna med hjälp av gradienter. Ange modellens parametrar och en inlärningshastighet.

model = CNN()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

Träningsloopen: Nollställ gradienter

Varje steg börjar med att gamla gradienter rensas med optimizer.zero_grad(). Om detta hoppas över ackumuleras gradienter över batcharna, vilket förstör era uppdateringar.

for images, labels in loader:
    optimizer.zero_grad()

Framåtpassering och förlust

Kör batchen genom modellen för att få prediktioner och beräkna sedan förlusten genom att jämföra prediktionerna med de sanna etiketterna. Förlusten är ett enda tal som mäter hur fel modellen har.

    outputs = model(images)
    loss = criterion(outputs, labels)

Bakåtpassering och steg

loss.backward() beräknar gradienter genom autograd, och optimizer.step() justerar vikterna så att förlusten minskar. Tillsammans utgör de ett inlärningssteg.

    loss.backward()
    optimizer.step()

Följ noggrannheten

Följ utvecklingen genom att räkna korrekta prediktioner. Ta argmax av utdata för att få de predikterade klasserna, jämför dem med etiketterna och dividera antalet träffar med det totala antalet.

    preds = outputs.argmax(dim=1)
    correct = (preds == labels).sum().item()
    acc = correct / labels.size(0)
    print("batch acc:", acc)

Snabb kontroll

Testa era kunskaper om träningsloopen.

Besvara frågan i den interaktiva lektionen

Sammanfattning: Bygga och träna CNN

Ni byggde ett CNN genom att skapa en underklass av nn.Module med lager av typen nn.Conv2d, nn.MaxPool2d och nn.Linear samt en metod forward. Ni tränade det med loopen: zero_grad, framåtpassering, loss.backward(), optimizer.step() och följde noggrannheten med argmax.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 53
Lektioner: 225

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Bygga och träna CNN-modeller i PyTorch” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär Er AI med Python, inklusive ”Bygga och träna CNN-modeller i PyTorch”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär Er AI med Python innehåller totalt 4 lektioner.

Vad lär jag mig i ”Bygga och träna CNN-modeller i PyTorch”?

nn.Conv2d, nn.MaxPool2d, nn.Linear, träningsloop, optimerare, förlust, uppföljning av träffsäkerhet. Ni övar på Lär Er AI med Python med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär Er AI med Python?

Du behöver inga förkunskaper. Utbildningen i Lär Er AI med Python på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Bygga och träna CNN-modeller i PyTorch”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär Er AI med Python-lektionen?

Ja. Varje Lär Er AI med Python-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär Er AI med Python