Tekniken bakom AI: Programmering

Programspråket Python

Att förstå grunderna i programmering handlar om mer än att bara skriva kod. Det är ett sätt att strukturera tankar och lösa problem systematiskt. Genom att behärska grundläggande logiska byggstenar och utnyttja moderna verktyg kan man gå från att vara passiv användare till att själv skapa intelligenta system.

Många AI-system och maskininlärningsmodeller skrivs i Python. Det är ett programmeringsspråk som är populärt eftersom det är relativt lätt att läsa, men ändå kraftfullt nog för att bygga avancerade program.

Python används i alla faser av AI-arbete:

• läsa in och rensa data
• göra beräkningar och statistik
• bygga algoritmer som hittar mönster
• träna modeller
• visualisera resultat i diagram.

När du programmerar i Python skriver du kod som datorn utför rad för rad. Python är känsligt för indrag (mellanslag och tabbar). Om du missar ett indrag kan programmet krascha eller göra något annat än du tänkt.

Vänj dig därför vid en ren kodstil: korta rader, tydliga variabelnamn och kommentarer som förklarar vad koden gör. En tydlig och väldokumenterad kod är dessutom mycket lättare för någon annan att förstå.

Grunderna i programmering

Att programmera handlar om att ge datorn exakta instruktioner. De viktigaste byggstenarna i de flesta programspråk är variabler, villkor, loopar och funktioner. Dessa delar kan kombineras till algoritmer som utför specifika uppgifter.

Variabler

Variabler är som namngivna lådor där värden sparas. De har ett namn och ett värde, och värdet kan ändras under programkörningen.

namn = "Karin"       # sträng (str)
alder = 17           # heltal (int)
langd = 1.72         # decimaltal (float)
ar_student = True    # boolesk (bool)

Det finns flera datatyper: str (text), int (heltal), float (decimaltal) och bool (sant/falskt). Kommandon används för att utföra operationer, som print() för att skriva ut något på skärmen.

print("Hej", namn)        # → Hej Karin
print(alder + 1)          # → 18

Listor

En lista lagrar flera värden i en och samma variabel. Det första elementet har alltid index 0, inte 1.

tal = [10, 20, 30]    # en lista med tre tal
print(tal[0])         # → 10 (första elementet)
print(len(tal))       # → 3 (antal element)

Villkor (if-satser)

Med villkor kan programmet ta olika vägar beroende på om ett påstående är sant eller falskt. Till exempel: om åldern är minst 18 ska en sak hända, annars något annat.

poang = 75

if poang >= 90:
    print("Betyg A")
elif poang >= 70:
    print("Betyg B")
else:
    print("Fortsätt öva!")

Loopar

En loop upprepar ett kodblock ett bestämt antal gånger eller så länge ett villkor är sant. Det är praktiskt när du vill gå igenom all data i en lista eller testa många möjligheter.

# for-loop: upprepar för varje element i en lista
frukter = ["äpple", "banan", "päron"]
for frukt in frukter:
    print(frukt)

# for-loop med range: upprepar 10 gånger
for i in range(10):
    print(i)          # i går från 0 till 9

# while-loop: upprepar tills villkoret är falskt
x = 0
while x < 5:
    print(x)
    x += 1

Observera att range(10) ger talen 0 till 9 – inte 1 till 10. Räknaren i börjar alltså på noll.

Funktioner

En funktion är ett namngivet, återanvändbart kodblock. Du definierar den en gång och anropar den hur många gånger som helst. Funktioner tar emot ett invärde, gör en beräkning och lämnar ifrån sig ett utvärde.

def hälsa(namn):
    return "Hej, " + namn + "!"

print(hälsa("Karin"))   # → "Hej, Karin!"
print(hälsa("Ahmad"))   # → "Hej, Ahmad!"

Funktioner är viktiga när du vill göra samma sak på många ställen, till exempel räkna ut ett felmått, normalisera data eller testa en modell.

Algoritmer

En algoritm är en detaljerad beskrivning av hur ett problem ska lösas steg för steg. Tänk på ett recept i matlagning: följer du stegen i rätt ordning får du ett förutsägbart resultat. Skillnaden är att en algoritm måste vara ännu tydligare än ett recept. En dator kan inte gissa vad du menar – den gör exakt det du säger.

Tekniskt sett omvandlar en algoritm ett invärde (input) till ett utvärde (output). Input kan vara en lista med tal, en bild eller en text. Output kan vara en sorterad lista, ett beslut eller en förutsägelse. I ett AI-system är algoritmen själva metoden som talar om hur modellen ska lära sig eller fatta beslut.

En bra algoritm har tre viktiga egenskaper:

• Tydlighet – varje steg får bara kunna tolkas på ett sätt. ”Sortera listan” är för otydligt. ”Jämför två tal i taget och byt plats om det vänstra är större” är tydligt.
• Systematik – den ska alltid fungera för samma typ av problem, oavsett om listan har 3 tal eller 3 000 tal.
• Ett slut – algoritmen får inte fastna i en oändlig loop.

Pseudokod

Algoritmer kan skrivas på vanlig svenska. Man kan också använda pseudokod – en slags ”låtsasprogrammering”. Man skriver instruktioner med ett programmeringslikt språk utan att låsa sig till ett visst programspråk. Så här kan en algoritm som hittar det största talet i en lista se ut som pseudokod:

störst = första talet
för varje tal i listan:
    om tal > störst:
        störst = tal
skriv ut störst

Samma algoritm i Python

def hitta_storst(lista):
    storst = lista[0]          # anta att första talet är störst
    for tal in lista:
        if tal > storst:
            storst = tal       # uppdatera om vi hittar något större
    return storst

print(hitta_storst([3, 7, 2, 9, 4]))   # → 9

Detta är en algoritm eftersom den är tydlig, fungerar för alla listor och definitivt tar slut. AI-algoritmer kan vara mycket mer avancerade, men bygger alltid på samma grundidé: ett tydligt recept för att lösa ett problem.

Hur löser människor och AI problem?

Människans problemlösning

När vi människor löser problem följer vi sällan en strikt steg-för-steg-metod. I stället bygger vår problemlösning på tre förmågor:

• Mönsterigenkänning – vi ser snabbt likheter med situationer vi mött tidigare. Studier av schackspelare visar att experter inte har bättre minne än andra, men är bättre på att känna igen mönster.
• Hantera begränsad information – vi fattar beslut även när pusselbitar saknas. Forskare kallar detta begränsad rationalitet: vi gör det bästa valet utifrån begränsad tid och information, ofta med mentala genvägar (heuristiker).
• Intuition och erfarenhet – ”magkänslan” bygger på lagrade erfarenheter. Brandmän, piloter och kirurger känner ofta igen rätt beslut innan de hunnit analysera situationen fullt ut.

AI:s problemlösning

Ett AI-system har ingen intuition, inga känslor och inga erfarenheter i mänsklig mening. All problemlösning bygger på algoritmer. Där människor gissar eller improviserar följer AI sin förutbestämda beslutsprocess. AI förstår inte problemet – den analyserar det.

Det finns flera sätt att skapa intelligenta system:

• Algoritmisk AI (klassisk AI) – följer tydliga regler som människor programmerat. Förutsägbar och exakt, men helt beroende av sina instruktioner.
• Kunskapsbaserad AI – bygger på mänsklig expertkunskap, till exempel medicinska rekommendationer som matchar fakta mot regler.
• Inlärningsbaserad AI (maskininlärning) – lär sig själv genom att hitta mönster i stora mängder data. Denna form dominerar i dag.

Just därför blir människor och AI tillsammans ofta starkare än var och en för sig. Människan bidrar med kreativitet, omdöme och etik. AI erbjuder snabbhet, precision och förmåga att upptäcka komplexa mönster.

Slutledning – tre sätt att dra slutsatser

Att dra slutsatser handlar om att utifrån tillgänglig information lista ut något nytt. AI kan basera slutledning på tre principer:

Logisk slutsats. En slutsats som måste vara sann om premisserna är sanna: Alla människor är dödliga. Sokrates är en människa. Alltså är Sokrates dödlig.

Statistisk slutsats. En sannolik gissning baserad på observationer: Om det regnar 90 procent av gångerna när himlen är grå, är det troligt att det regnar nu. Ju fler observationer, desto pålitligare sannolikhet. Statistiska slutsatser är bästa gissningar – aldrig garantier.

Villkorslösning. Att hitta en lösning som uppfyller givna regler. Sudoku är ett typiskt exempel: systemet testar alternativ, backar när något blir fel och fortsätter tills alla villkor är uppfyllda. Samma idé används i schemaläggning och ruttplanering.

Sökning och spelteori

Vissa problem går ut på att hitta ett specifikt objekt bland många, eller en väg genom en miljö. Sådana problem löses genom sökning. Det är grunden för många AI-tillämpningar, från schackprogram till GPS-navigering. I det här avsnittet möter du fem sökmetoder:

• Bredden först (BFS) – undersöker allt på samma nivå innan nästa
• Djupet först (DFS) – följer en väg så långt det går, backar sedan
• Girig sökning – väljer alltid det som ser bäst ut för stunden
• A*-sökning – väger ihop avverkad sträcka och uppskattad återstående sträcka
• Minimax – sökning med motstånd, för spel mot en motspelare.

Problemdomän, träd och grafer

Innan sökningen kan börja måste vi beskriva världen som problemet finns i – dess problemdomän. För en kartapp är domänen kartan med alla platser och vägar. För en dammsugarrobot är den rummet och alla positioner roboten kan stå på. Problemdomänen kan beskrivas matematiskt med träd eller grafer.

Ett träd består av noder (punkter) och kanter (förbindelser) utan slutna ringar. Överst finns en rotnod. Varje nod kan ha barnnoder, och en nod utan barn kallas blad. Träd passar för hierarkier: en katalogstruktur (mapp → undermapp → fil), ett beslutsträd eller ett spelträd där rotnoden är startbrädet och bladen är slutställningar.

En graf består också av noder och kanter, men kan innehålla cykler. Noderna är tillstånd (”roboten står i rum A”), kanterna är övergångar (”flytta åt höger”). Kanter kan vara viktade (med en kostnad som tid eller avstånd), riktade (enkelriktade) eller oriktade. I en karta kan noderna vara städer, kanterna vägar och vikterna avstånd.

Beslutsträd

Ett beslutsträd visar hur ett system fattar beslut steg för steg. Varje nod är en fråga, varje gren ett möjligt svar. Tänk dig en AI som föreslår lunch: ”Är du vegetarian?” → ja/nej → ”Varm eller kall mat?” → till slut hamnar du i ett blad, till exempel ”Tofu pad thai”. I maskininlärning används beslutsträd för att klassificera data, som att avgöra om ett mejl är spam.

Bredden först (BFS)

BFS undersöker allt som ligger lika långt från startpunkten innan den söker längre bort. Tänk dig att du står vid skolans entré och letar efter matsalen. Med BFS kollar du först alla salar på våning ett. Hittar du inte matsalen går du vidare till våning två, sedan våning tre.

BFS hittar garanterat den kortaste vägen så länge alla steg kostar lika mycket. Nackdelen är minnet: metoden måste spara alla möjligheter på varje nivå – som att hålla alla skolans korridorer i huvudet samtidigt.

Djupet först (DFS)

DFS går i stället så djupt den kan. Tänk dig en elev som kliver in i första bästa korridor och följer den så långt det går. Vid en låst dörr går eleven tillbaka till senaste korsningen och testar nästa väg.

DFS är mycket minnessnål – den håller bara reda på den väg den just undersöker. Men den kan fastna i långa sidospår och hittar inte alltid den kortaste vägen.

Heuristisk sökning

I små världar som Tre i rad har vi råd att testa alla vägar. Men i en hel stadskarta eller stor spelvärld blir mängden val enorm. Då är både BFS och DFS för långsamma. Algoritmen behöver en gissning om vilka vägar som verkar lovande.

En heuristik är en enkel tumregel som uppskattar hur nära målet ett tillstånd verkar vara – datorns motsvarighet till ”magkänsla”. Ett klassiskt exempel är fågelvägen: du vet inte exakt vilka gator du ska ta, men du vet åt vilket håll målet ligger. Ett kortare fågelvägsavstånd betyder att en sökning i den riktningen är mest lovande.

Även i sudoku används heuristik: börja med de rutor som har flest begränsningar, alltså där flest siffror redan finns i samma rad, kolumn eller box. Det minskar sökträdets storlek kraftigt.

Girig sökning

Girig sökning (Greedy Best-First Search) väljer alltid det alternativ som verkar ligga närmast målet just nu – som att i varje ögonblick gå åt det håll matsalen ”borde ligga” fågelvägen. Metoden är snabb och ofta effektiv i öppna miljöer. Men den kan leda rakt mot målet och fastna vid en vägg, som när man följer mobilens pil i ett köpcentrum utan att se hindren.

A* – informerad sökning

A* (uttalas ”A-stjärna”) förbättrar girig sökning genom att kombinera två mått vid varje vägval:

• g(n) – den faktiska kostnaden hittills, alltså hur lång väg som redan passerats
• h(n) – en heuristisk uppskattning av återstående väg, till exempel fågelvägen.

Summan f(n) = g(n) + h(n) avgör vilket alternativ som ser mest lovande ut. Algoritmen utforskar alltid noden med lägst f-värde.

Exempel: du står vid en korsning i skolan och ska till matsalen. Korridor A ligger 30 meter bort och därifrån är det cirka 25 meter fågelvägen kvar: f(A) = 30 + 25 = 55. Korridor B ligger bara 10 meter bort, men vägen därifrån slingrar sig – ungefär 60 meter kvar: f(B) = 10 + 60 = 70. A* väljer korridor A, trots att B känns närmare just nu. Så undviks girig sökningens fälla med återvändsgränder.

A* används i nästan alla system som navigerar runt hinder: GPS-appar, robotar, självkörande dammsugare och spelkaraktärer. Den hittar vanligen den kortaste vägen utan att behöva testa alla alternativ.

Sökning med motstånd: Minimax

I spel mot en motståndare räcker det inte att hitta en bra väg – du måste också förutse motståndarens drag. Minimax resonerar så här: ”Motståndaren kommer att göra drag som är dåliga för mig. Därför väljer jag det drag som är bäst även i värsta fall.”

I Tre i rad kallas din spelare MAX (vill maximera värdet) och motståndaren MIN (vill minimera det). Varje slutställning får ett värde: +1 för vinst för MAX, −1 för vinst för MIN och 0 för oavgjort. Algoritmen söker igenom spelträdet nedifrån och upp. På MAX nivåer väljs det högsta värdet, på MIN:s nivåer det lägsta.

Exempel: MAX har två drag att välja mellan. Drag A låter MIN vinna direkt, så värde(A) = −1. Drag B tvingar MIN att blockera och leder till oavgjort, så värde(B) = 0. Minimax väljer B. Hade det funnits ett drag C med värdet +1 hade det valts i stället.

Om båda spelarna spelar optimalt i Tre i rad blir resultatet alltid oavgjort – det kan räknas ut redan innan spelet börjar. En Minimax-spelare kan därför aldrig förlora mot någon som också spelar optimalt. Värdena behöver inte vara −1, 0 och +1: i Othello kan de variera mellan −64 och +64.

Minimax kräver fullständig kunskap om alla spelmöjligheter. Det fungerar i små spel som Tre i rad. I stora spel som schack blir trädet enormt, och därför används varianter med avklippning – man skippar grenar som inte kan påverka valet – för att spara tid.

Programmeringsfel och felsökning

När man programmerar blir det ofta fel. Datorn gör alltid exakt som du skriver – inte det du menade. Fel i kod kallas buggar. Det finns tre typer:

• Syntaxfel – koden bryter mot språkets regler och kan inte ens köras.
• Körtidsfel – koden körs men kraschar under körning (t.ex. division med noll).
• Logikfel – koden körs utan fel men ger fel svar.

Programmering är mycket ”trial and error”: skriv ett kodstycke, testa, få fel, hitta orsaken och korrigera. Med tiden lär man sig att tänka systematiskt, dela upp problemet i mindre delar och bygga lösningen steg för steg.

x = "3"          # en sträng, går inte att räkna med
x = int(x)       # nu är x heltalet 3
print(x + 1)     # → 4

tal = [10, 20, 30]
print(tal[0])    # → 10, listor börjar på index 0

for i in range(3):
    print(i)     # skriver ut 0, 1, 2

Google Colab

Google Colab (kort för Collaboratory) är ett kostnadsfritt onlineverktyg för AI-programmering. Det kräver ingen installation – du skriver, kör och delar Python-kod direkt i webbläsaren. Colab kombinerar text, kod och resultat i samma dokument och används ofta i utbildning och forskning.

Eftersom allt körs i molnet behöver du ingen kraftfull dator. I Colab kan du köra program, ladda upp och analysera datafiler, visualisera resultat och träna enklare AI-modeller.

Så här kommer du igång:

1. Gå till colab.research.google.com
2. Logga in med ett Google-konto
3. Skapa ett nytt "Notebook" eller öppna ett befintligt
4. Spara en kopia på din Google Drive via menyn Arkiv → Spara en kopia i Drive
5. Kör kodceller med ▶-knappen eller Shift+Enter

Ett Colab-dokument består av kodceller och textceller. Med ”Kör alla” i menyn körs alla kodceller i tur och ordning. Om du ändrar i en kodcell måste du köra cellen igen med Play-knappen för att ändringen ska slå igenom. Nya celler skapas med knapparna ”+ Kod” och ”+ Text”.

AI-assisterad kodning

Med AI-assisterad kodning kan numera vem som helst programmera, utan djupa förkunskaper. I en kodcell i Colab kan du skriva kod manuellt eller ta hjälp av chattbotten Gemini för att generera kod. Du beskriver med ord vad du vill att koden ska göra.

Ett bra sätt att lära sig AI är att göra egna laborationer och lära sig genom att testa, så kallad tinkering. Du behöver inte börja med ett tomt dokument. Be i stället AI:n skapa ett första utkast, till exempel:

När laborationen är klar kan du köra den direkt i Colab. Är något för svårt? Be AI:n förenkla, skriva fler kommentarer eller förklara varje steg. Du kan också be om extra uppgifter: ändra en variabel, byta modell eller använda fler datapunkter. Så kan du börja enkelt och utveckla labben stegvis.

Det viktiga är att använda AI:n som en hjälpreda, inte som en genväg. Målet är att du ska förstå vad koden gör. Läs igenom varje kodförslag, kör det steg för steg och fråga dig själv: ”Varför gör vi det här?” Då blir varje laboration ett träningspass i både AI-promptning och programmering.