Sannheten er at “kunstig intelligens” er et begrep med mange betydninger. Britannica definerer kunstig intelligens (eller “AI”) som:

"Artificial intelligence (AI) [is] the ability of a digital computer or computer-controlled robot to perform tasks commonly associated with intelligent beings."

SNL derimot, definerer kunstig intelligens som:

"Kunstig intelligens er informasjonsteknologi som justerer sin egen aktivitet og derfor tilsynelatende framstår som intelligent."

PwC på sin side, definerer kunstig intelligens som:

"Kunstig intelligens (KI), eller «Artificial Intelligence (AI)» på engelsk, handler om å utvikle datasystemer som kan lære av egne erfaringer og løse komplekse problemer i ulike situasjoner og miljøer. Hvis en maskin kan løse problemer, utføre en oppgave eller vise andre kognitive funksjoner som et menneske kan så kan vi si at det har kunstig intelligens."

PwC henviser på sin side også til regjeringen.no, som har følgende definisjon:

"Kunstig intelligente systemer utfører handlinger, fysisk eller digitalt, basert på tolkning og behandling av strukturerte eller ustrukturerte data, i den hensikt å oppnå et gitt mål."

Alle disse definisjonene er problematiske. Først og fremst er det ikke slik at kunstig intelligens må kunne lære og justere egen oppførsel. La oss for eksempel si at vi har en kunstig intelligens som kjører bil helt perfekt, men ikke innehar noen evne til å lære (av feil). Sistnevnte mangel vil ikke diskvalifisere den fra å bli regnet som en kunstig intelligens av alle som ser dens overlegne kjøreferdigheter.

Det er åpenbart også en del maskiner som kan løse såkalte menneskelige problemer som ihvertfall i historisk kontekst ikke er å regne som kunstig intelligens. Eksempelvis en vevmaskin.

Regjeringen sin definisjon er også problematisk. Det er liten forskjell på regjeringen sin definisjon av “kunstig intelligente systemer” og en vilkårlig definisjon av et dataprogram. Den er også lang, vanskelig å huske, og hvorfor nevne både strukturert og ustrukturert data når begge inkluderes?

Samtidig er det nettopp dette som er problemet med “kunstig intelligens”: det er et bredt begrep som omfatter mye. Det er dermed vanskelig å definere.

Engelske Wikipedia sin definisjon illustrerer dette godt:

"Artificial intelligence (AI), in its broadest sense, is intelligence exhibited by machines, particularly computer systems."

Oversatt til norsk:

Kunstig intelligens (KI), i sin bredeste forstand, er intelligens utvist av maskiner, spesifikt datamaskiner.

Egentlig har vi bare redusert definisjonsproblemet til å definere “intelligens”. Samtidig er dette et spørsmål vi i større grad har en intuitiv forståelse av. Ved å akseptere at “kunstig intelligens” er intelligens i konteksten av maskinell utførelse, og muligens spesifikt i konteksten av datamaskiner, har vi en definisjon som er grei å forholde seg til og enkel å huske.

For å underbygge definisjonen vår og overbevise oss om at den gir mening, gir vi her en del eksempler jeg tror vi kan være enig om at er “kunstig intelligens”:

• ChatGPT.
• Midjourney og Dall-E.
• Selvkjørende biler.
• Sjakkprogrammer som enkelt gruser verdens beste sjakkspillere (sorry Magnus). Ev. Go-programmer som knuser verdens beste Go-spillere, om du foretrekker Go over sjakk.
• Den nye Optimus-robotten til Tesla.
• Chatbotter på nettsider, som aldri klarer å hjelpe deg med det du faktisk trenger.
• Heldigitale assistenter som gjør oppgaver på din kommando.

Historikk

Kunstig intelligens

Få disipliner har en like definert start som kunstig intelligens. I 1956 samlet John McCarty en gruppe akademikere til det som har blitt kjent som The Darthmouth Summer Researech Project on Artificial Intelligence. Prosjektets formelle beskrivelse, skrevet av McCarthy med flere, gir en god indikasjon både på hva man tenkte at KI var og skulle være:

We propose that a 2-month, 10-man study of artificial intelligence be carried out during the summer of 1956 at Dartmouth College in Hanover, New Hampshire. The study is to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it. An attempt will be made to find how to make machines use language, form abstractions and concepts, solve kinds of problems now reserved for humans, and improve themselves. We think that a significant advance can be made in one or more of these problems if a carefully selected group of scientists work on it together for a summer.[1]

Begrepet “Artificial Intelligence” ble spesifikt laget av McCarthy for anledningen.

Turing og turing-testen

Allerede før dette hadde matematikeren Alan Turing forsket mye på tenkende maskiner. En av oppfinnelsene han er mest kjent for er Turing testen. Den ble introdusert i artikkelen Computing Machinery and Intelligence, utgitt i 1959.

Turing-testen er en test som indikerer hvorvidt en maskin innehar intelligens som er umulig å skille fra intelligensen til et menneske. Idéen i testene er at en dommer, et menneske, observerer naturlig språk mellom en maskin og et menneske. Dommeren vet at én av deltagerne er en maskin (dette er ikke helt tydeliggjort i Turing sitt originale manusskript). Om dommeren ikke klarer å skille hvem som er menneske og hvem som er maskinen bestått turing-testen.

Turing-testen har og er en viktig komponent i verden av kunstig intelligens. Ved den nylige lanseringen av ChatGPT gikk det ikke lang tid før det ble sjekket om den slår Turing-testen. Noe den gjør[2].

Nevrale nettverk

Grunnleggende nettverk

Mye forskning innenfor kunstig intelligens omhandler det som kalles for “nevrale nettverk”.

I konteksten av kunstig intelligens er et nevralt nettverk en datamodell som er inspirert av biologiske nevrale nettverk i dyr.

Nettverkene fungerer ved at man har en mengde noder (som etterligner nevroner) og en mengde koblinger mellom nodene (som etterligner synapser).

Man skiller typisk mellom tre lag i et klassisk nevralt nettverk: Det inngående laget (”input layer”), det skjulte laget (”hidden layer”) og det utgående laget (”output layer”).

Inn i det nevrale nettverket sender man tall. Første til det inngående laget. Når en node tar i mot et tall, tar den tallene den har fått, sender tallene igjennom en formel kalt en aktiveringsfunksjon, som regner ut et nytt tall som er den utgående verdien noden skal sende videre. Denne verdien sendes videre over alle de utgående koblingene fra noden.

Dette simulerer hvordan hjernen vår fungerer. I hjernen sendes elektriske impulser mellom nevronene våre. Hvert nevron har en innebygd aktiveringsfunksjon, som er mer kompleks enn modellene vi typisk bruker i kunstige nevrale nettverk. Når et nevron mottar en elektrisk impuls vil hvorvidt det sender et impuls videre, og styrken på dette impulset, variere avhengig av nevronets  interne “aktiveringsfunksjon”.

Vekting

Koblingene mellom nodene (gjerne kalt “kanter”, “edges” på Engelsk) har alle en tallverdi. Denne verdien kalles for en vekt. Denne vekten indikerer hvor sterk en kobling er mellom to noder. Et tall som sendes ut én node til en annen vil multipliseres med vekten til kanten mellom nodene.

Når man skal lage et nevralt nettverk for å løse en oppgave er det i praksis to jobber man må gjøre:

1. Designe nettverket. Hvor mange noder skal vi ha, og hvordan skal de kobles til hverandre?
2. Sette vekter på alle kantene.

I prinsippet er dette alt som trengs. Problemet er at det er fryktelig mange nettverk man kan lage, og en uendelig mengde forskjellige tall man kan sette på vektene.

Så hvordan velger man riktige vekter?

Læring og bakoverpropagering

For å sette riktige vekter på et nevralt nettverk må man trene nettverket.

Si for eksempel man har et nettverk som man ønsker skal detektere om et bilde inneholder en katt eller ikke. De inngående nodene til nettverket kan settes opp til å ta imot pikslene til bildene. Man trenger dermed én node per piksel, og om man har bilder i ulike størrelser må man normalisere de. Det kan være én utgående node som tolkes slik at om noden har verdien 1 er det en katt i bildet, og har noden verdien 0 er det ikke en katt i bildet.

For å trene dette nettverket forbereder man gjerne tusenvis av bilder av katter (om ikke mer) og tusenvis av bilder uten katter. For hvert bilde har man en sekvens (vektor) med tall som representerer pikslene til bildet, og et tall 0 eller 1 som indikerer om bildet inneholder en katt eller ikke. Dette er treningsdataen til nettverket.

Deretter kjører vi hvert bilde igjennom nettverket vårt, som typisk har blitt satt opp med helt tilfeldige vekter på kantene. På andre siden får vi en verdi som indikerer om nettverket tror det er en katt eller ikke i bildet. Til å begynne med vil dette nettverket sannsynligvis predikere helt feil. For kjøring kan vi gjøre en prossess som heter Bakoverpropagering. Dette tar verdien som kom ut av nettverket (som sannsynligvis ikke er nøyaktig likt det vi forventer), og “propagerer” feilen bakover i nettverket, og justerer hver kant slik at feilen skal bli mindre ved neste kjøring. Hvor mye hver kant justeres hver gang kalles for læringsraten til treningen.

Bakoverpropagering er det som tillater oss å trene nevrale nettverk på store datamengder, og med de få de til å gjøre de utroligste ting. Uten bakoverpropagering hadde hvert tall i et nettverk måtte settes på en manuell eller annen systematisk måte av ingeniørene som lager nettverkene.

For ChatGPT-4 er det snakk om rundt 1 800 milliarder slike tall som må trenes. Med andre ord noe som er helt utilgjengelig å gjennomføre manuelt.

Bakoverpropagering ble først publisert av Seppo Linnainmaa i 1970[3].

Universalitet

Nevrale nettverk er nyttige verktøy for å løse komplekse problemer. Siden vi kan trene nettverkene på store datamengder er det lett å tenke seg at alle problemer kan omformes til treningsdata og trenes på et nettverk.

Dette er en tanke som også har en viss støtte i matematikken. Nevrale nettverk er nemlig universelle funksjonsapproksimatorer. Enkelt oppsummert betyr det at nevrale nettverk i teorien kan etterlignende vilkårlige matematiske funksjoner. Og siden vilkårlige matematiske funksjoner i stor grad kan beskrive de fleste problemer vi ønsker å løse i dataverden, kan nevrale nettverk også dette.

Dette kalles for universalitet.

Viktige sekundære spørsmål er dog: A) Hvor lett er det å approksimere en funksjon (et problem) med et nevralt nettverk, B) Har vi nok treningsdata? og C) Finnes det lettere måter å løse problemet på?

Svaret på disse spørsmålene kan ofte peke mot at nevrale nettverk ikke er riktig metode for å løse et visst problem.

Eksempel

Her er et eksempel på et veldig enkelt nevralt nettverk skrevet (av ChatGPT) for å etterlikne XOR-formelen:

import numpy as np

# Activation functions and their derivatives
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# Training data (X: inputs, y: outputs)
X = np.array([[0, 0],
              [0, 1],
              [1, 0],
              [1, 1]])

y = np.array([[0], [1], [1], [0]])  # XOR problem

# Seed for reproducibility
np.random.seed(42)

# Initialize weights
input_size = 2
hidden_size = 2
output_size = 1

weights_input_hidden = np.random.rand(input_size, hidden_size)
weights_hidden_output = np.random.rand(hidden_size, output_size)

# Learning rate
lr = 0.1

# Training loop
for epoch in range(10000):
    # Forward pass
    hidden_input = np.dot(X, weights_input_hidden)
    hidden_output = sigmoid(hidden_input)

    final_input = np.dot(hidden_output, weights_hidden_output)
    final_output = sigmoid(final_input)

    # Calculate error
    error = y - final_output
    if epoch % 1000 == 0:
        print(f'Epoch {epoch}, Error: {np.mean(np.abs(error))}')

    # Backpropagation
    d_output = error * sigmoid_derivative(final_output)
    d_hidden = d_output.dot(weights_hidden_output.T) * sigmoid_derivative(hidden_output)

    # Update weights
    weights_hidden_output += hidden_output.T.dot(d_output) * lr
    weights_input_hidden += X.T.dot(d_hidden) * lr

# Test the network
print("\nTesting the network:")
for i, x in enumerate(X):
    hidden_output = sigmoid(np.dot(x, weights_input_hidden))
    final_output = sigmoid(np.dot(hidden_output, weights_hidden_output))
    print(f"Input: {x}, Predicted Output: {final_output}, Actual Output: {y[i]}")

‍