Professionella verktyg

Vi har nu byggt, tränat och förstått neurala nätverk från grunden. Vi har kodat neuroner, aktiveringsfunktioner och till och med den ökända backpropagation-algoritmen för hand. Du har nu en djupare förståelse för "magin" än de flesta som bara använder färdiga verktyg.

Men som du kanske märkt finns det gränser för vår handskrivna Python-klass:

1. Hastighet: Python-loopar är långsamma. Moderna nätverk kräver miljarder beräkningar som måste köras parallellt på grafikkort (GPU:er).
2. Komplexitet: Att manuellt räkna ut derivator för komplexa nätverk med hundratals lager är en mardröm och extremt felbenäget.
3. Standardisering: För att samarbeta behöver vi gemensamma språk.

I detta kapitel introducerar vi Deep Learning-ramverk (specifikt Keras/TensorFlow) och några av de verktyg som krävs för att bygga professionella AI-system.

Vi kommer också att gå igenom de avgörande komponenter och hantverksknep som gör skillnaden mellan en modell som "funkar" och en som presterar bra.

---

Från Kod till Keras

Innan vi dyker ner i nya koncept, låt oss översätta din kunskap. Du kan redan allt detta, du behöver bara lära dig det nya ordförrådet.

I tabellen nedan ser du hur koden du skrev i förra kapitlet mappas direkt mot Keras, branschens mest populära bibliotek för nybörjare och proffs.

Koncept	Din kod (Kapitel 6)	Keras / TensorFlow
Arkitektur	NeuralNetwork(layers=[2, 3, 1])	model = Sequential([Dense(3), Dense(1)])
Neuronen	self.weights, self.bias	Hanteras automatiskt inuti Dense-lagret
Matematiken	dot_product(inputs, weights) + bias	Dense gör detta, optimerat för GPU
Aktivering	def sigmoid(x): ...	activation='sigmoid' eller activation='relu'
Felfunktion	error = target - prediction	loss='mse' eller loss='categorical_crossentropy'
Lärande	weight += rate * delta	optimizer='adam' eller optimizer='sgd'

Att bygga XOR i Keras

Låt oss se hur vårt XOR-problem från förra kapitlet ser ut med professionella verktyg.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# 1. Definiera Modellen (Arkitekturen)
# Vi bygger en "Sequential" modell (lager på lager)
model = Sequential([
    # Dold lager: 2 neuroner, tar emot 2 inputs
    Dense(2, input_dim=2, activation='sigmoid'),
    # Output lager: 1 neuron (svaret)
    Dense(1, activation='sigmoid')
])

# 2. Kompilera (Bestäm regler för träning)
# Optimizer: "adam" (en smartare version av vår learning rate)
# Loss: "mean_squared_error" (samma matte som vi använde)
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['accuracy'])

# 3. Data (Samma som förut)
X = [[0,0], [0,1], [1,0], [1,1]]
y = [[0], [1], [1], [0]]

# 4. Träna (Fit)
model.fit(X, y, epochs=5000, verbose=0)

# 5. Testa
print(model.predict(X))

Ser du? Det är exakt samma logik, men 100 rader kod har blivit 10. Och under huven sker samma matrismultiplikationer, bara många gånger snabbare.

---

Träningskomponenterna: En Djupdykning

Nu när vi har verktygen för att bygga nätverk enkelt, kan vi fokusera på hur vi får dem att lära sig bäst. Det räcker inte med bara "Gradient Descent". Vi behöver välja rätt verktyg för varje del av processen.

1. Förlustfunktioner (Loss Functions)

Hur mäter vi "hur fel" nätverket har? Detta är kompassen som styr träningen.

• MSE (Mean Squared Error): Används för Regression (t.ex. huspriser). Straffar stora fel hårt. Det är denna princip (att minimera kvadraten på felet) som vi använde i vår handkodade version.
• Cross-Entropy Loss (Log Loss): Används för Klassificering (t.ex. Katt vs Hund). Mäter hur väl den förutsagda sannolikhetsfördelningen matchar verkligheten. Om nätverket är 100% säker på "Katt" men det är en "Hund", ger denna funktion ett enormt straff.

2. Optimerare (Optimizers)

Gradient Descent är strategin att gå nerför berget. I vår egen kod tog vi enkla steg (vikt -= rate * gradient). Men det finns smartare sätt att gå.

• SGD (Stochastic Gradient Descent): Tar snabba, skakiga steg baserat på en liten del av datan åt gången.
• Adam (Adaptive Moment Estimation): Den moderna standarden och din bästa vän. Tänk dig en tung boll som rullar nerför berget. Den har momentum (fart) och anpassar sin hastighet för varje parameter individuellt. Den bromsar in i skarpa kurvor och gasar på raksträckor. I 9 fall av 10 ska du välja optimizer='adam'.

3. Aktiveringsfunktioner

Vi använde Sigmoid, men den har problem (den "dödar" gradienten för mycket stora/små tal, vilket gör att djupa nätverk slutar lära sig).

• ReLU (Rectified Linear Unit): f(x) = max(0, x). Den ser ut som en hockeyklubba. Den är enkel, supersnabb att beräkna och löser många matematiska problem med djupa nätverk. Idag är detta standard i de flesta dolda lager.
• Softmax: Används i sista lagret för klassificering med flera val (t.ex. siffror 0-9). Den tvingar alla outputs att summera till 1.0 (100%), vilket ger oss en snygg sannolikhetsfördelning: "Jag är 90% säker på att det är en sjua, 5% på en etta...".

4. Att Stoppa Överträning (Regularization)

Ett kraftfullt nätverk kan bli för bra. Det kan börja memorera träningsdatan utantill istället för att lära sig mönstren. Detta kallas Överträning (Overfitting) och är AI-utvecklarens värsta fiende. Vi måste göra det svårare för nätverket att fuska.

• Dropout: En genial teknik. Under träning stänger vi slumpmässigt av t.ex. 50% av neuronerna i varje steg. Nätverket tvingas bli robust och inte lita för mycket på någon enskild neuron ("The Brain Damage analogy"). I Keras lägger du bara till Dropout(0.5) som ett lager.
• Early Stopping: Vi övervakar felet på en separat valideringsmängd (data nätverket inte tränar på). När felet börjar öka på valideringsdatan (trots att det minskar på träningsdatan), vet vi att nätverket börjat memorera. Då avbryter vi träningen direkt.

---

Hantverket: Från Rådata till Modell

Att känna till algoritmerna är en sak. Att få dem att fungera i verkligheten är en annan. En Data Scientist lägger ofta 80% av sin tid på datapreparering och bara 20% på själva modelleringen. "Garbage In, Garbage Out" är lagen.

1. Hantera det som saknas (NaNs)

Verklig data är smutsig. Värden saknas (NaN - Not a Number). En enda NaN kan krascha hela din beräkning.

• Drop: Kasta bort rader som saknar data? (Enkelt, men risk att tappa information).
• Impute: Gissa värdet? (T.ex. fyll i med medelvärdet av alla andra rader).

2. Att tala nätverkets språk: One-Hot Encoding

Datorer förstår bara siffror. Hur matar man in "Röd", "Grön", "Blå"? Om vi översätter dem till 1, 2, 3 tror nätverket att "Blå" (3) är "mer" än "Röd" (1). Det är fel.

Lösningen är One-Hot Encoding. Vi skapar en ny "flagga" för varje färg.

• Röd $\rightarrow$ [1, 0, 0]
• Grön $\rightarrow$ [0, 1, 0]
• Blå $\rightarrow$ [0, 0, 1]

Nu är alla färger matematiskt lika långt ifrån varandra.

3. Skalning av data (Normalization)

Ett vanligt misstag är att mata in rådata där olika inputs har helt olika skalor, t.ex. Ålder (0–100) och Lön (0–50 000).

Om du matar in jättestora tal (som 50 000) måste nätverket hitta en extremt liten vikt för att balansera kalkylen. Detta gör träningen instabil och långsam. Vi vill att alla inputs ska "spela på samma planhalva", helst mellan 0 och 1.

Hur gör man?

1. Min-Max Normalization: Skalar om datan så att alla värden tvingas in mellan 0 och 1.
   • Formel: (värde - min) / (max - min)
2. Standardization (Z-score): Centrerar datan runt 0. Medelvärdet blir 0 och standardavvikelsen 1. Bra om datan har extrema utliggare.

4. Validering: Cross-Validation

Att bara dela upp data i Train/Test en gång kan vara riskabelt (du kanske hade tur/otur med uppdelningen). K-Fold Cross-Validation: Dela datan i 5 delar. Träna på 4, testa på 1. Rotera och upprepa 5 gånger. Medelvärdet ger en mycket mer sann bild av modellens kvalitet.

---

Övningar

I detta kapitel ska vi ta klivet över till Keras. Målet är att du ska känna dig bekväm med syntaxen och se hur mycket snabbare du kan experimentera.

Övning 1: XOR i Keras (Hello World)

Syfte: Bekräfta att du kan bygga och träna en modell i Keras.

1. Kopiera koden för XOR-exemplet ovan.
2. Kör den.
3. Experimentera: Vad händer om du tar bort det dolda lagret? Kan den lösa XOR då? (Ledtråd: Linjär separerbarhet).

Övning 2: Från Handkodad till Keras (Titanic)

Syfte: Ta ett problem du löste "för hand" i förra kapitlet och lös det med moderna verktyg.

1. Ladda Titanic-datasetet (precis som i förra kapitlet).
2. Gör samma datapreparering (ta bort NaNs, normalisera, One-Hot för kön).
3. Bygg en Keras-modell:
   • Input layer: Motsvarar antalet features du har.
   • Hidden layers: Testa dig fram! Kanske två lager med 16 neuroner vardera? Använd activation='relu'.
   • Output layer: 1 neuron (överlevde/dog) med activation='sigmoid'.
   • Loss: binary_crossentropy (eftersom det är ja/nej).
4. Jämför: Går det snabbare? Får du bättre resultat?

Övning 3: Fashion MNIST (Bildklassificering)

Syfte: Att bygga ditt första riktiga bildigenkänningsnätverk med Keras. Istället för tråkiga siffror använder vi Fashion MNIST: 70 000 bilder på kläder (tröjor, byxor, skor...).

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 1. Ladda data
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

# 2. Titta på datan
print(X_train.shape) # (60000, 28, 28)
plt.imshow(X_train[0], cmap='gray')
plt.show()

# 3. Preparera
# Normalisera till 0-1
X_train = X_train / 255.0
X_test = X_test / 255.0

# Keras vill ha en platt lista (om vi använder Dense-lager) 
# Men Keras har ett 'Flatten'-lager som gör detta åt oss!

# 4. Bygg modellen
model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)), # Gör om 28x28 bild till 784 pixlar
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dropout(0.2), # Minska överträning
    tf.keras.layers.Dense(10, activation='softmax') # 10 klädkategorier
])

# 5. Kompilera
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 6. Träna
model.fit(X_train, y_train, epochs=5)

# 7. Utvärdera
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_acc}")

Uppdrag:

• Kör koden. Vilken noggrannhet får du?
• Lägg till fler lager. Blir det bättre?
• Detta nätverk behandlar bilden som en platt rad pixlar. Den vet inte att pixel 1 och pixel 28 (som är under varandra) hänger ihop. För att lösa det behöver vi nästa kapitels superhjälte: CNN.