Deel 4 van 5: Een AI creëren die echt van jou is

Welkom terug! We hebben RAG-systemen en fine-tuning van bestaande modellen behandeld. Vandaag gaan we volledig DIY — een taalmodel helemaal zelf bouwen. Nu, voordat je denkt "dat is veel te complex voor mij," stop ik je meteen. Wat we bouwen zal GPT-5 niet vervangen, maar het zal volledig van jou zijn, draait op jouw hardware, met jouw data.

Waarom je eigen model bouwen?

Je vraagt je misschien af, "Waarom het wiel opnieuw uitvinden als ChatGPT bestaat?" Hier is waarom:

Volledige Privacy: Je data verlaat nooit je computer. Geen API-aanroepen, geen externe afhankelijkheden.

Nul Doorlopende Kosten: Na training is het gratis om voor altijd te gebruiken.

Volledige Controle: Jij bepaalt wat het leert, hoe het zich gedraagt, en wanneer het bijgewerkt wordt.

Domein Focus: Een klein model getraind op jouw specifieke use case kan grote modellen overtreffen voor gerichte taken.

Wat we bouwen

Ik zal je laten zien hoe je een aangepast taalmodel maakt met PyTorch. Ons voorbeeld richt zich op kennis van MyNextDeveloper, maar je kunt dit aanpassen voor elk domein — juridische documenten, technische handleidingen, responsies voor klantenservice, noem het maar op.

Je AI-werkplaats instellen

Eerst zorgen we dat onze tools klaar zijn. Je hebt Python en een paar bibliotheken nodig. Maak je geen zorgen als je geen codeerexpert bent — ik leg alles stap voor stap uit.

import torch

import torch.nn as nn

import numpy as np

import matplotlib.pyplot as plt

from collections import Counter

import re

import math

Als je Google Colab gebruikt (wat ik beginners aanbeveel), zijn de meeste hiervan al geïnstalleerd.

Stap 1: De AI leren woorden begrijpen

Voordat ons model taal kan leren, moet het begrijpen wat woorden zijn. Dit proces heet tokenisatie — tekst in stukken verdelen die de computer kan verwerken.

class ImprovedTokenizer:

def __init__(self):

self.vocab = {}

self.inverse_vocab = {}

def build_vocab(self, text, min_freq=1): # Convert to lowercase and split into words and punctuation text = text.lower() words = re.findall(r'w+|[.!?,:;]', text) word_counts = Counter(words) # Create vocabulary with special tokens self.vocab = {'<PAD>': 0, '<UNK>': 1, '<START>': 2, '<END>': 3} for word, count in word_counts.items(): if count >= min_freq and word not in self.vocab: self.vocab[word] = len(self.vocab) self.inverse_vocab = {v: k for k, v in self.vocab.items()} print(f"Vocabulary size: {len(self.vocab)}")

Wat gebeurt hier? We creëren een woordenboek waar elk uniek woord een nummer krijgt. Denk eraan als het geven van elk woord in je domein een ID-kaart.

Stap 2: De trainingsgegevens voorbereiden

Ons model leert door naar woordenreeksen te kijken en te proberen te voorspellen wat er volgt. Het is als iemand een taal leren door miljarden zinsfragmenten te tonen.

class ImprovedTextDataset:

def __init__(self, text, tokenizer, seq_length=32):

self.tokenizer = tokenizer

tokens = tokenizer.encode(text)

self.data = []

# Create input-output pairs for i in range(len(tokens) - seq_length): input_seq = tokens[i:i+seq_length] target_seq = tokens[i+1:i+seq_length+1] self.data.append((input_seq, target_seq))

Dit creëert duizenden voorbeelden waarbij het model een woordenreeks ziet en leert welk woord volgende moet komen.

Stap 3: Het brein van onze AI

Nu komt het spannende gedeelte — het bouwen van het daadwerkelijke neurale netwerk. We gebruiken een Transformer-architectuur, hetzelfde type dat ChatGPT aandrijft, alleen kleiner.

class ImprovedTransformer(nn.Module):

def __init__(self, vocab_size, embed_dim=256, num_heads=8, num_layers=6):

super().__init__()

# Convert words to numbers the model can understand

self.token_embedding = nn.Embedding(vocab_size, embed_dim)

# Add position information so model knows word order self.pos_encoding = PositionalEncoding(embed_dim) # The transformer layers - where the magic happens encoder_layer = nn.TransformerEncoderLayer( d_model=embed_dim, nhead=num_heads, dim_feedforward=embed_dim * 4, dropout=0.1 ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) # Final layer to predict next words self.head = nn.Linear(embed_dim, vocab_size)

Dit netwerk leert patronen in taal door woordenreeksen te verwerken via meerdere lagen van wiskundige transformaties.

Stap 4: Model trainen

Hier leren we ons model alles over je domein:

def train(self, document_text, epochs=80, batch_size=4, learning_rate=0.0003):

# Prepare the data

dataset = self.prepare_data(document_text)

dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# Create the model self.model = ImprovedTransformer(vocab_size=self.tokenizer.vocab_size) # Set up the learning process optimizer = optim.AdamW(self.model.parameters(), lr=learning_rate) criterion = nn.CrossEntropyLoss() # Training loop for epoch in range(epochs): total_loss = 0 for inputs, targets in dataloader: # Forward pass outputs = self.model(inputs) loss = criterion(outputs.view(-1, self.tokenizer.vocab_size), targets.view(-1)) # Backward pass optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() if epoch % 10 == 0: print(f"Epoch {epoch}, Loss: {total_loss/len(dataloader):.4f}")

Het trainingsproces is als het model duizenden voorbeelden tonen en het geleidelijk zijn gissingsmogelijkheid laten verbeteren.

Stap 5: Alles samenbrengen

Laten we ons model trainen op informatie van MyNextDeveloper:

# knowledge base

mnd_corpus = """

MyNextDeveloper (MND) is a remote-first tech company founded in 2022 in Mumbai.

They focus on supplying pre-vetted, highly skilled developers to startups.

Their mission is to solve the trust gap between startups and engineers by

emphasizing empathy, communication, and transparency.The company promotes agile practices, test-driven development, and

POSH-compliant culture. MND offers services like staff augmentation,

API and web development, UI/UX design, and AI/ML solutions.

"""

# Create and train the model

llm = ImprovedTopicLLM()

llm.train(mnd_corpus, epochs=80, batch_size=4, learning_rate=0.0003)

Stap 6: Je creatie testen

Nadat training compleet is, kun je chatten met je aangepaste AI:

# Test different prompts

prompts = [

"What is MyNextDeveloper known for?",

"Where is MyNextDeveloper headquartered?",

"What technologies do they use?",

"How do they ensure trust?"

]

for prompt in prompts: response = llm.generate(prompt, max_length=30) print(f"Question: {prompt}") print(f"Answer: {response}")

Google Colab

Google Colab-link voor dit artikel is hier en kan in één klik worden uitgevoerd: link

Verwachtingen managen

Laten we eerlijk zijn over wat je krijgt. Je aangepaste model zal:

✅ Voordelen:

Volledig privé en veilig zijn
Zonder internetverbinding werken
Na training niets kosten
Perfect afgestemd zijn op je domein
Reacties onmiddellijk genereren

❌ Beperkingen:

Geen algemene wereldkennis hebben
Kan repetitieve reacties produceren
Vereist trainingsdata van hoge kwaliteit
Vraagt om tijd en moeite om correct te trainen
Zal niet de veelzijdigheid van GPT-4 matchen

Real-world toepassingen

Hier zijn enkele praktische toepassingen voor aangepaste modellen:

Klantenservice: Train op je FAQ en ondersteuningstickets voor directe, consistente reacties.

Technische documentatie: Maak een model dat vragen kan beantwoorden over je specifieke software of processen.

Inhoudsgenerering: Genereer productbeschrijvingen, e-mailsjablonen of sociale mediaberichten in je merkstem.

Juridisch/Compliance: Train op je industrieregels voor snelle beleidsopzoekingen.

Trainingstips die echt werken

1. Kwaliteit boven kwantiteit: 1.000 goed geschreven voorbeelden verslaan 10.000 willekeurige.

2. Wees consistent: Als je trainingsdata inconsistent is, zal je model dat ook zijn.

3. Begin klein: Begin met een gericht domein in plaats van alles proberen te behandelen.

4. Test vroeg en vaak: Genereer reacties gedurende training om vroeg problemen op te vangen.

5. Sla je modellen op: Sla altijd getrainde modellen op zodat je niet helemaal opnieuw hoeft te trainen.

De economie van aangepaste modellen

Laten we over kosten praten:

Training: Bij gebruik van cloud GPU's, verwacht $5–20 voor een klein model.

Uitvoeren: Volledig gratis na training.

Tijdsinvestering: Kost tijd om te bouwen, daarna grotendeels geautomatiseerd

Onderhoud: Kan bijwerken wanneer je kennisbank verandert

Vergelijk dit met API-kosten: als je maandelijks duizenden queries maakt, betaalt een aangepast model zich snel terug.

Wat kan er misgaan?

Overfitting: Het model onthoudt je trainingsdata maar kan niet generaliseren. Oplossing: Gebruik meer diverse voorbeelden en kortere training.

Underfitting: Het model leert niet genoeg. Oplossing: Train langer of gebruik meer data.

Repetitieve reacties: Het model zit in lussen vast. Oplossing: Pas temperatuur en top-k parameters aan tijdens generering.

Slechte datakwaliteit: Vuilnis erin, vuilnis eruit. Oplossing: Spendeer tijd aan het schoonmaken en verbeteren van je trainingstekst.

Schalen

Als je eenmaal een werkend model hebt, wil je misschien:

Grotere modellen trainen met meer parameters
Meerdere modellen voor verschillende domeinen combineren
Meer geavanceerde generatietechnieken implementeren
Een eenvoudige webinterface bouwen voor anderen om te gebruiken

Vooruitblik

We hebben een taalmodel helemaal zelf gebouwd — iets dat een paar jaar geleden onmogelijk leek. In ons laatste artikel zal ik je laten zien hoe je je AI-tools met de echte wereld verbindt met Model Context Protocol (MCP), ze van geïsoleerde systemen in krachtige, verbonden assistenten verandert.

Aangepaste taalmodellen zijn niet langer alleen voor techgiganten. Met de juiste aanpak kan elk bedrijf AI creëren die hun domein echt begrijpt en hun taal spreekt. Het is misschien geen GPT, maar het is van jou, en soms is dat precies wat je nodig hebt.

Volgende: Artikel 5 — "Je AI met de wereld verbinden: MCP in actie"