PyTorch-tensorer: Skapa, bearbeta och överföra till GPU
Ni kommer att skapa tensorer från Python-listor och NumPy-arrayer, utföra elementvisa operationer och matrisoperationer samt flytta tensorer till GPU med .to('cuda').
PyTorch-tensorer: Skapa, bearbeta och överföra till GPU är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad är en PyTorch-tensor?
En tensor är den grundläggande datastrukturen i PyTorch — i praktiken en n-dimensionell array, ungefär som en NumPy-array, men med inbyggt GPU-stöd och automatisk differentiering. Tensorer kan vara skalärer (0D), vektorer (1D), matriser (2D) eller strukturer med fler dimensioner. PyTorch-tensorer spårar beräkningshistoriken, vilket möjliggör automatisk gradientberäkning vid träning av neurala nätverk.
import torch
# Scalar (0-dimensional tensor)
scalar = torch.tensor(3.14)
print(scalar.shape) # torch.Size([])
# Vector (1D)
vector = torch.tensor([1.0, 2.0, 3.0])
print(vector.shape) # torch.Size([3])
# Matrix (2D)
matrix = torch.tensor([[1, 2], [3, 4]])
print(matrix.shape) # torch.Size([2, 2])Skapa tensorer: vanliga metoder
PyTorch tillhandahåller många fabriksfunktioner för att skapa tensorer med specifika värden eller former. torch.zeros och torch.ones fyller tensorer med konstanter; torch.rand samplar från en likformig fördelning; torch.randn samplar från en standardnormalfördelning. Dessa är byggstenar för viktinitiering och generering av syntetiska data.
import torch
zeros = torch.zeros(3, 4) # 3x4 matrix of zeros
ones = torch.ones(2, 3) # 2x3 matrix of ones
rand_uniform = torch.rand(3, 3) # uniform in [0, 1)
rand_normal = torch.randn(3, 3) # standard normal N(0,1)
arange = torch.arange(0, 10, 2) # [0, 2, 4, 6, 8]
print(zeros.dtype) # torch.float32 (default)
print(arange) # tensor([0, 2, 4, 6, 8])Skapa tensorer från NumPy-arrayer
Ofta börjar du med en NumPy-array (från Pandas, scikit-learn med mera) och behöver konvertera den till en PyTorch-tensor. torch.from_numpy delar minne med NumPy-arrayen — om du ändrar den ena ändras även den andra. Alternativt skapar torch.tensor en kopia. Om du vet vilken du ska använda undviker du oväntade fel i datapipelines.
import torch
import numpy as np
arr = np.array([1.0, 2.0, 3.0])
# Shares memory with arr
t_shared = torch.from_numpy(arr)
# Makes an independent copy
t_copy = torch.tensor(arr)
arr[0] = 99.0
print(t_shared) # tensor([99., 2., 3.]) <- changed
print(t_copy) # tensor([1., 2., 3.]) <- unchangedTensorernas datatyper (dtypes)
Tensorer har en dtype som styr numerisk precision och minnesanvändning. Standardvärdet är torch.float32, vilket är standardtypen för vikter i neurala nätverk. torch.float64 ger högre precision men använder dubbelt så mycket minne; torch.int64 används för heltalsetiketter. Datatyper som inte matchar orsakar körningsfel, så kontrollera och konvertera alltid uttryckligen med .float() eller .to(dtype).
import torch
f32 = torch.tensor([1.0, 2.0]) # float32 by default
f64 = torch.tensor([1.0, 2.0], dtype=torch.float64)
i64 = torch.tensor([1, 2, 3]) # int64 by default
print(f32.dtype) # torch.float32
print(i64.dtype) # torch.int64
# Cast to float32
labels = i64.float()
print(labels.dtype) # torch.float32Elementvisa aritmetiska operationer
PyTorch överlagrar Pythons vanliga aritmetiska operatorer för elementvisa operationer på tensorer med samma form. Addera, subtrahera, multiplicera och dividera fungerar alla elementvis. Dessa operationer är kraftigt optimerade och körs på GPU:n när tensorerna ligger på en CUDA-enhet. In-place-operationer (t.ex. add_) ändrar tensoren direkt utan att allokera nytt minne.
import torch
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
print(a + b) # tensor([5., 7., 9.])
print(a * b) # tensor([ 4., 10., 18.])
print(b / a) # tensor([4., 2.5, 2.])
print(a ** 2) # tensor([1., 4., 9.])
# In-place add
a.add_(1.0)
print(a) # tensor([2., 3., 4.])Matrismultiplikation med torch.matmul
Matrismultiplikation är den centrala operationen i varje lager i ett neuralt nätverk. torch.matmul (eller operatorn @) utför matrismultiplikation och hanterar automatiskt batcher av matriser med broadcasting. För 2D-indata beräknas en vanlig matrisprodukt; för 3D eller högre utförs batchad matrismultiplikation. Så här beräknar ett linjärt lager output = input @ weight.T + bias.
import torch
A = torch.randn(3, 4) # 3x4
B = torch.randn(4, 5) # 4x5
C = torch.matmul(A, B) # 3x5
print(C.shape) # torch.Size([3, 5])
# Equivalent using @ operator
C2 = A @ B
print(torch.allclose(C, C2)) # True
# Batched matmul
batch_A = torch.randn(8, 3, 4) # batch of 8 matrices
batch_B = torch.randn(8, 4, 5)
result = batch_A @ batch_B # torch.Size([8, 3, 5])Ändra tensorers form: view och reshape
Att ändra formen på en tensor utan att ändra dess data är en av de vanligaste operationerna inom deep learning. view kräver att tensoren är sammanhängande i minnet och returnerar en vy (med delade data); reshape fungerar även på icke-sammanhängande tensorer genom att kopiera vid behov. Använd -1 som en jokerdimension så beräknar PyTorch den korrekta storleken. Att platta ut en 2D-funktionskarta till en 1D-vektor före ett linjärt lager är ett typiskt användningsfall.
import torch
t = torch.arange(12).float() # tensor of 12 elements
print(t.shape) # torch.Size([12])
m = t.view(3, 4) # reshape to 3x4
print(m.shape) # torch.Size([3, 4])
m2 = t.view(2, -1) # PyTorch infers 6 columns
print(m2.shape) # torch.Size([2, 6])
# Flatten to 1D
flat = m.reshape(-1)
print(flat.shape) # torch.Size([12])Broadcasting: arbeta med olika former
Broadcasting gör att PyTorch kan utföra operationer på tensorer med olika former genom att implicit utvidga dimensioner. Reglerna är hämtade från NumPy: dimensionerna justeras från höger och en dimension med storleken 1 kan tänjas ut så att den matchar den andra tensoren. Broadcasting gör explicit duplicering av data onödig och sparar minne. Det används hela tiden i lager i neurala nätverk för att lägga till biasvektorer i batchade utdatasetmatriser.
import torch
# Matrix (3x4) + vector (4,) -- vector broadcast over rows
matrix = torch.ones(3, 4)
bias = torch.tensor([1.0, 2.0, 3.0, 4.0]) # shape (4,)
result = matrix + bias
print(result.shape) # torch.Size([3, 4])
print(result[0]) # tensor([2., 3., 4., 5.])
# Column vector (3,1) * row vector (1,4) -> (3,4)
col = torch.arange(1, 4).float().unsqueeze(1) # (3,1)
row = torch.arange(1, 5).float().unsqueeze(0) # (1,4)
print((col * row).shape) # torch.Size([3, 4])Kontrollera enheter: CPU kontra CUDA
Varje tensor finns på en enhet: antingen cpu eller en CUDA-GPU, till exempel cuda:0. Genom att kontrollera om enheten är tillgänglig med torch.cuda.is_available() kan du skriva kod som är oberoende av enhet. Alla tensorer som ingår i en beräkning måste finnas på samma enhet — om du försöker addera en CPU-tensor och en GPU-tensor uppstår ett körningsfel. Standardmönstret är att skapa en device-variabel och flytta allt till den.
import torch
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)
# Create tensor directly on the chosen device
t = torch.randn(3, 3, device=device)
print(t.device)
# Move an existing CPU tensor to the device
cpu_tensor = torch.tensor([1.0, 2.0, 3.0])
gpu_tensor = cpu_tensor.to(device)
print(gpu_tensor.device)Flytta tensorer till GPU:n med .to('cuda')
Att träna neurala nätverk på en GPU kan vara 10–100 gånger snabbare än på CPU för stora modeller. När du har bekräftat att CUDA är tillgängligt flyttar du tensorer till GPU:n med .to('cuda') eller .cuda(). Flytta tillbaka dem till CPU:n för konvertering till NumPy med .cpu() (NumPy kan inte komma åt GPU-minne direkt). Anropet .detach() tar bort en tensor från beräkningsgrafen innan den konverteras till NumPy.
import torch
# Simulate GPU workflow (falls back to CPU gracefully)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Move model weights and data to GPU
weights = torch.randn(256, 128).to(device)
inputs = torch.randn(32, 128).to(device) # batch of 32
outputs = inputs @ weights.T # matmul on device
print(outputs.shape) # torch.Size([32, 256])
# Convert back to NumPy for visualization
np_out = outputs.detach().cpu().numpy()
print(type(np_out)) # <class 'numpy.ndarray'>Användbara tensorattribut och verktyg
Flera tensorattribut och verktygsfunktioner är viktiga för felsökning och formning av data. .shape anger dimensionerna; .numel() returnerar det totala antalet element; .dtype visar datatypen; .requires_grad anger om gradienter kommer att spåras. Funktioner som torch.cat, torch.stack och torch.squeeze används hela tiden för att sätta samman batcher och ta bort dimensioner med storleken 1.
import torch
t = torch.randn(4, 3, 2)
print(t.shape) # torch.Size([4, 3, 2])
print(t.numel()) # 24
print(t.dtype) # torch.float32
# Concatenate along dim 0
a = torch.ones(2, 3)
b = torch.zeros(3, 3)
cat = torch.cat([a, b], dim=0) # shape (5, 3)
print(cat.shape)
# Remove size-1 dimensions
x = torch.randn(1, 5, 1)
print(x.squeeze().shape) # torch.Size([5])Snabbtest
Testa dina kunskaper om begreppen maskininlärning med Python från den här lektionen.
Sammanfattning av lektionen
I den här lektionen lärde du dig: tensorer är PyTorches centrala datastruktur för n-dimensionella arrayer på CPU eller GPU, skapandefunktioner som torch.zeros, torch.randn och torch.from_numpy ger flexibla sätt att initiera data, och att flytta tensorer till GPU:n med .to(device) är det viktiga steget för att snabba upp träningen av deep learning-modeller. Härnäst utforskar vi automatisk differentiering med Autograd.
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
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”PyTorch-tensorer: Skapa, bearbeta och överföra till GPU” gratis?
Ja – hela texten till ”PyTorch-tensorer: Skapa, bearbeta och överföra till GPU” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”PyTorch-tensorer: Skapa, bearbeta och överföra till GPU”?
Ni kommer att skapa tensorer från Python-listor och NumPy-arrayer, utföra elementvisa operationer och matrisoperationer samt flytta tensorer till GPU med .to('cuda'). Ni övar på Machine Learning Academy 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 Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy 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 1 av 4.
Hur lång tid tar lektionen ”PyTorch-tensorer: Skapa, bearbeta och överföra till GPU”?
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 Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-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
- PyTorch-tensorer: Skapa, bearbeta och överföra till GPU
- Autograd: Automatisk derivering för backpropagation
- Bygga ett feedforward-nätverk med nn.Module
- Träningsloop: Förlust, optimerare och epoker