Elk AI-systeem moet data opslaan en snel terugvinden. Of het nu gaat om pixelwaarden in een afbeelding, een vocabulaire van 50.000 woorden of miljoenen gebruikersvoorkeuren - de keuze van datastructuur bepaalt hoe snel je AI kan denken.
Twee structuren domineren: arrays en hash maps. Beheers deze twee en je hebt de basis voor vrijwel elke AI-pipeline.
Een array is simpelweg een genummerde lijst van items die naast elkaar in het geheugen staan. Elk item heeft een index - zijn positie in de lijst, beginnend bij nul.
index: 0 1 2 3 4
value: ["cat", "dog", "bird", "fish", "frog"]
Omdat items naast elkaar staan, kun je direct naar elke positie springen. Item 3 nodig? Klaar - geen zoekwerk vereist. Dat is O(1) toegang: het kost evenveel tijd of de array nu 10 of 10 miljoen items bevat.
Invoegen of verwijderen in het midden is duur. Elk item na de wijziging moet opschuiven. Dat is O(n) - hoe meer items, hoe langer het duurt.
Stel je hebt een playlist van 10.000 nummers en je wilt een nieuw nummer invoegen op positie 5. Elk nummer vanaf positie 5 moet opschuiven. Hoe zou een streamingdienst dit aanpakken zonder traag te worden?
Een hash map (ook wel dictionary of hash table genoemd) slaat data op als key-value paren. In plaats van toegang via een indexnummer, gebruik je een betekenisvolle sleutel.
word_counts = {
"hello": 42,
"world": 37,
"AI": 156
}
Sign in to join the discussion
De telling van "AI" nodig? De hash map gebruikt een hash function om de sleutel achter de schermen om te zetten naar een index. Het resultaat? Gemiddeld O(1) opzoektijd - net als arrays, maar dan met namen in plaats van nummers.
Python's dictionaries zijn hash maps. Wanneer ChatGPT woordfrequenties telt tijdens training, gebruikt het hash-map-achtige structuren om miljarden woordvoorkomens bij te houden uit alle tekst op het internet.
| Operatie | Array | Hash Map | |----------|-------|----------| | Toegang via index | O(1) ⚡ | N/A | | Toegang via sleutel | O(n) 🐢 | O(1) ⚡ | | Invoegen aan het einde | O(1) ⚡ | O(1) ⚡ | | Invoegen in het midden | O(n) 🐢 | N/A | | Zoeken naar waarde | O(n) 🐢 | O(1) ⚡ |
Zie O(1) als "instant, ongeacht de grootte" en O(n) als "trager naarmate de data groter wordt."
Je hebt 100.000 gebruikersprofielen en moet een gebruiker vinden op gebruikersnaam. Welke structuur is het snelst?
Een van de meest bruikbare patronen in zowel interviews als AI is het tellen van voorkomens:
counts = {}
for each word in text:
if word in counts:
counts[word] = counts[word] + 1
else:
counts[word] = 1
Eén doorgang door de tekst geeft je de frequentie van elk woord. Taalmodellen gebruiken precies deze aanpak (op enorme schaal) om te begrijpen welke woorden het belangrijkst zijn.
Gegeven een array van getallen en een doelwaarde: vind twee getallen die samen de doelwaarde vormen. De naïeve aanpak controleert elk paar - O(n²). De slimme aanpak gebruikt een hash map:
seen = {}
for each number in array:
complement = target - number
if complement in seen:
return [seen[complement], current_index]
seen[number] = current_index
Eén doorgang, O(n) tijd. De hash map onthoudt wat je al gezien hebt.
Waarom is de hash map-aanpak voor two-sum sneller dan elk paar controleren?
Een aanbevelingssysteem moet controleren of een gebruiker een film al heeft gezien voordat het die aanraadt. Zou je de kijkgeschiedenis opslaan in een array of een hash map? Welke afwegingen spelen mee?
Een AI-model slaat word embeddings op als arrays van 300 getallen. Waarom zijn arrays hier een goede keuze?