Del 4 af 5: Sådan får du en AI, der er helt din egen

Velkommen tilbage! Vi har dækket RAG-systemer og finetuning af eksisterende modeller. I dag går vi all-in på DIY — vi bygger en sprogmodel fra bunden. Nu, før du tænker "det er alt for komplekst for mig," skal jeg stoppe dig lige der. Det, vi bygger, kommer ikke til at erstatte GPT-5, men det bliver helt dit, kører på dit hardware med dine data.

Hvorfor bygge sin egen model?

Du undrer dig måske: "Hvorfor opfinde hjulet på ny, når ChatGPT eksisterer?" Her er grunden:

Komplet privathed: Dine data forlader aldrig din computer. Ingen API-kald, ingen eksterne afhængigheder.

Nul løbende omkostninger: Når den er trænet, er den gratis at køre for evigt.

Fuld kontrol: Du bestemmer, hvad den lærer, hvordan den opfører sig, og hvornår den opdateres.

Domænefokus: En lille model trænet på dit specifikke use case kan overgå gigantiske modeller til snævre opgaver.

Hvad vi bygger

Jeg viser dig, hvordan du laver en brugerdefineret sprogmodel ved hjælp af PyTorch. Vores eksempel fokuserer på MyNextDeveloper-virksomhedsvidenbase, men du kan tilpasse det til ethvert domæne — juridiske dokumenter, tekniske manualer, kundeservicerespons, du kalder det.

Sådan sætter du dit AI-værksted op

Først skal vi få vores værktøjer klar. Du har brug for Python og nogle få biblioteker. Bekymr dig ikke, hvis du ikke er en kodningsekspert — jeg forklarer alt trin for trin.

import torch

import torch.nn as nn

import numpy as np

import matplotlib.pyplot as plt

from collections import Counter

import re

import math

Hvis du bruger Google Colab (hvilket jeg anbefaler for begyndere), er de fleste af disse allerede installeret.

Trin 1: At lære AI at forstå ord

Før vores model kan lære sprog, skal den forstå, hvad ord er. Denne proces hedder tokenisering — at dele tekst op i brikker, som computeren kan arbejde med.

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)}")

Hvad sker der her? Vi opretter en ordbog, hvor hvert unikt ord får et nummer. Tænk på det som at give hvert ord i dit domæne et ID-kort.

Trin 2: Forberedelse af træningsdata

Vores model lærer ved at se på ordsekvenser og forsøge at forudsige, hvad der kommer næste gang. Det er som at lære nogen et sprog ved at vise dem millioner af sætningsfragmenter.

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))

Dette opretter tusindvis af eksempler, hvor modellen ser en ordsekvens og lærer, hvilket ord der skal komme næste gang.

Trin 3: Hjernen i vores AI

Nu kommer den spændende del — at bygge det egentlige neurale netværk. Vi bruger en Transformer-arkitektur, samme type, der driver ChatGPT, bare mindre.

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)

Dette netværk lærer sprokmønstre ved at behandle ordsekvenser gennem flere lag af matematiske transformationer.

Trin 4: Træning af model

Her lærer vi vores model alt om dit domæne:

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}")

Træningsprocessen er som at vise modellen tusindvis af eksempler og lade den gradvist forbedre sin gætteevne.

Trin 5: At sammensætte det hele

Lad os træne vores model på MyNextDeveloper-virksomhedsoplysninger:

# 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)

Trin 6: At teste dit værk

Når træningen er afsluttet, kan du chatte med din brugerdefinerede 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 til denne artikel findes her og kan køres med ét klik: link

At håndtere forventninger

Lad os være ærlige om, hvad du får. Din brugerdefinerede model vil:

✅ Fordele:

Være helt privat og sikker
Køre uden internetforbindelse
Koste ingenting efter træning
Være perfekt skræddersyet til dit domæne
Generere svar øjeblikkeligt

❌ Begrænsninger:

Vil ikke have almengyldig verdenskundskab
Kan producere gentagne svar
Kræver træningsdata af høj kvalitet
Tager tid og indsats at træne korrekt
Kan ikke matche GPT-4's alsidighed

Virkelige applikationer

Her er nogle praktiske anvendelser for brugerdefinerede modeller:

Kundeservice: Træn på dine FAQ og supportbilletter for øjeblikkelige, konsistente svar.

Teknisk dokumentation: Opret en model, der kan besvare spørgsmål om dine specifikke software eller processer.

Indholdsgenerering: Generer produktbeskrivelser, emailskabeloner eller indlæg til sociale medier i din brand stemme.

Juridisk/overholdelse: Træn på dine brancheregler for hurtige politiklookups.

Trætningstips, der faktisk virker

1. Kvalitet fremfor mængde: 1.000 velskrevne eksempler slår 10.000 tilfældige.

2. Vær konsistent: Hvis dine træningsdata er inkonsistente, bliver din model det også.

3. Start småt: Begynd med et fokuseret domæne i stedet for at prøve at dække alt.

4. Test tidligt og ofte: Generer svar gennem hele træningen for at fange problemer tidligt.

5. Gem dine modeller: Gem altid trænet modeller, så du ikke skal træne fra bunden igen.

Økonomien for brugerdefinerede modeller

Lad os tale omkostninger:

Træning: Hvis du bruger cloud GPU'er, forventer du $5–20 for en lille model.

Kørsel: Helt gratis når den er trænet.

Tidsomkostning: Det tager tid at bygge, derefter automatiseret for det meste

Vedligeholdelse: Kan opdateres, når din videnbase ændres

Sammenlign dette med API-omkostninger: hvis du laver tusindvis af forespørgsler månedligt, betaler en brugerdefineret model sig selv hurtigt.

Hvad kan gå galt?

Overfitting: Modellen udenadslærer dine træningsdata, men kan ikke generalisere. Løsning: Brug mere mangfoldige eksempler og kortere træning.

Underfitting: Modellen lærer ikke nok. Løsning: Træn længere eller brug mere data.

Gentagne svar: Modellen sidder fast i sløjfer. Løsning: Juster temperatur- og top-k-parametre under generering.

Dårlige data: Skrald ind, skrald ud. Løsning: Brug tid på at rense og forbedre din træniningstekst.

Skalering op

Når du har en fungerende model, kan du måske:

Træne større modeller med flere parametre
Kombinere flere modeller til forskellige domæner
Implementere mere sofistikerede generationsteknikker
Bygge en simpel webgrænseflade til andre at bruge

Kigger fremad

Vi har bygget en sprogmodel fra bunden — noget der lignede umuligt for blot få år siden. I vores sidste artikel viser jeg dig, hvordan du forbinder dine AI-værktøjer til den virkelige verden ved hjælp af Model Context Protocol (MCP), og forvandler dem fra isolerede systemer til kraftfulde, forbundne assistenter.

Brugerdefinerede sprogmodeller er ikke længere kun for tech-giganter. Med den rigtige tilgang kan enhver virksomhed skabe AI, der virkelig forstår deres domæne og taler deres sprog. Det er måske ikke GPT, men det er dit, og nogle gange er det præcis, hvad du har brug for.

Kommende: Artikel 5 — "At forbinde din AI til verden: MCP i aktion"