Del 4 av 5: Skapa AI som är helt ditt eget

Välkommen tillbaka! Vi har täckt RAG-system och finjustering av befintliga modeller. Idag går vi helt DIY — vi bygger en språkmodell från grunden. Nu, innan du tänker "det är väl alldeles för komplext för mig", låt mig stoppa dig där. Det vi bygger kommer inte att ersätta GPT-5, men det kommer att vara helt ditt, kört på din hårdvara, med dina data.

Varför bygga din egen modell?

Du kanske undrar, "Varför uppfinna hjulet på nytt när ChatGPT finns?" Här är varför:

Fullständig integritet: Dina data lämnar aldrig din dator. Inga API-anrop, inga externa beroenden.

Noll löpande kostnader: När den väl är tränad är den gratis att köra för alltid.

Fullständig kontroll: Du bestämmer vad den lär sig, hur den beter sig och när den uppdateras.

Domänfokus: En liten modell tränad på ditt specifika användningsfall kan överträffa gigantiska modeller för snäva uppgifter.

Vad vi bygger

Jag visar dig hur du skapar en anpassad språkmodell med PyTorch. Vårt exempel fokuserar på MyNextDeveloper-företagskunskap, men du kan anpassa det för vilken domän som helst — juridiska dokument, tekniska manualer, kundservicesvar, du namn det.

Ställa in ditt AI-verkstad

Först, låt oss få våra verktyg klara. Du behöver Python och några bibliotek. Oroa dig inte om du inte är en kodningsexpert — jag förklarar allt steg för steg.

import torch

import torch.nn as nn

import numpy as np

import matplotlib.pyplot as plt

from collections import Counter

import re

import math

Om du använder Google Colab (vilket jag rekommenderar för nybörjare) är de flesta av dessa redan installerade.

Steg 1: Lära AI att förstå ord

Innan vår modell kan lära sig språk måste den förstå vad ord är. Denna process kallas tokenisering — att dela upp text i bitar som datorn kan arbeta 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)}")

Vad händer här? Vi skapar en ordbok där varje unikt ord får ett nummer. Tänk på det som att ge varje ord i din domän ett ID-kort.

Steg 2: Förbereda träningsdata

Vår modell lär sig genom att titta på ordsekvenser och försöka förutsäga vad som kommer härnäst. Det är som att lära någon ett språk genom att visa dem miljoner meningsFragment.

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

Det här skapar tusentals exempel där modellen ser en ordsekvens och lär sig vilket ord som bör komma härnäst.

Steg 3: Hjärnan på vår AI

Nu kommer den spännande delen — att bygga det faktiska neurala nätverket. Vi använder en Transformer-arkitektur, samma typ som driver ChatGPT, bara 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)

det här nätverket lär sig mönster i språk genom att bearbeta ordsekvenser genom flera lager av matematiska transformationer.

Steg 4: Träning av modell

Här är där vi lär vår modell allt om din domän:

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 är som att visa modellen tusentals exempel och låta den gradvis förbättra sin gissningsförmåga.

Steg 5: Sätta ihop allt

Låt oss träna vår modell på MyNextDeveloper-företagsinformation:

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

Steg 6: Testa din skapelse

När träningen är klar kan du chatta med din anpassade 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-länk för denna artikel finns här och kan köras med ett klick: länk

Hantera förväntningar

Låt oss vara ärliga om vad du får. Din anpassade modell kommer att:

✅ Fördelar:

Vara helt privat och säker
Köras utan internetanslutning
Kosta ingenting efter träning
Vara perfekt anpassad till din domän
Generera svar direkt

❌ Begränsningar:

Kommer inte att ha allmän världskunskap
Kan producera repetitiva svar
Kräver högkvalitativ träningsdata
Tar tid och ansträngning att träna ordentligt
Kommer inte att motsvara GPT-4:s mångsidighet

Verklig tillämpning i praktiken

Här är några praktiska användningsfall för anpassade modeller:

Kundservice: Träna på dina FAQ och supportbiljetter för omedelbar, konsekvent service.

Teknisk dokumentation: Skapa en modell som kan svara på frågor om din specifika programvara eller processer.

Innehållsgenerering: Generera produktbeskrivningar, e-postmallar eller inlägg i sociala medier med ditt märkes röst.

Juridik/Efterlevnad: Träna på dina industriregler för snabb policyöverslagning.

Träningstips som faktiskt fungerar

1. Kvalitet framför kvantitet: 1 000 välskrivna exempel slår 10 000 slumpmässiga.

2. Var konsekvent: Om din träningsdata är inkonsekvent kommer din modell att vara det också.

3. Börja smått: Börja med en fokuserad domän snarare än att försöka täcka allt.

4. Testa tidigt och ofta: Generera svar under träningen för att fånga problem tidigt.

5. Spara dina modeller: Spara alltid tränade modeller så att du inte behöver träna om från början.

Ekonomin för anpassade modeller

Låt oss prata kostnader:

Träning: Om du använder moln-GPU:er, räkna med $5–20 för en liten modell.

Drift: Helt gratis när den väl är tränad.

Tidsinvestering: Det tar tid att bygga, sedan oftast automatiserat

Underhåll: Kan uppdateras när din kunskapsbas ändras

Jämför det här med API-kostnader: om du gör tusentals frågor varje månad, betalar sig en anpassad modell snabbt.

Vad kan gå fel?

Överanpassning: Modellen memorerar din träningsdata men kan inte generalisera. Lösning: Använd mer varierande exempel och kortare träning.

Underanpassning: Modellen lär sig inte tillräckligt. Lösning: Träna längre eller använd mer data.

Repetitiva svar: Modellen fastnar i loopar. Lösning: Justera temperatur- och top-k-parametrar under generering.

Dålig datakvalitet: Skräp in, skräp ut. Lösning: Använd tid på att rensa och förbättra din träningstext.

Skala upp

När du väl har en fungerande modell kanske du vill:

Träna större modeller med fler parametrar
Kombinera flera modeller för olika domäner
Implementera mer sofistikerade genereringsteknik
Bygga ett enkelt webbgränssnitt för andra att använda

Framåtblick

Vi har byggt en språkmodell från grunden — något som verkade omöjligt för bara några år sedan. I vår sista artikel visar jag dig hur du ansluter dina AI-verktyg till den verkliga världen med Model Context Protocol (MCP), och förvandlar dem från isolerade system till kraftfulla, anslutna assistenter.

Anpassade språkmodeller är inte bara för teknikjättar längre. Med rätt tillvägagångssätt kan vilken verksamhet som helst skapa AI som verkligen förstår sin domän och talar sitt språk. Det kanske inte är GPT, men det är ditt, och ibland är det exakt vad du behöver.

Kommer nästa: Artikel 5 — "Ansluta din AI till världen: MCP i aktion"