Dio 4 od 5: Stvaranje AI-ja koji je zaista tvoj
Dobrodošli nazad! Pokrili smo RAG sustave i fino podešavanje postojećih modela. Danas idemo full DIY — gradimo jezični model od nule. Sada, prije nego što pomisliš "to je valjda previše komplicirano za mene", zaustavio bih te. Ono što gradimo neće zamijeniti GPT-5, ali će biti potpuno tvoje, pokreće se na tvojoj opremi, s tvojim podacima.
Zašto graditi vlastiti model?
Možda se pitaš, "Zašto ponovno izumijevati kotač kada ChatGPT već postoji?" Evo zašto:
Potpuna privatnost: Tvoji podaci nikada ne napuštaju tvoje računalo. Nema API poziva, nema vanjskih ovisnosti.
Nema tekućih troškova: Kada je obučen, besplatan je za zauvijek.
Puna kontrola: Ti odlučuješ što uči, kako se ponaša i kada se ažurira.
Fokus na domenu: Mali model obučen na tvojoj specifičnoj upotrebi može nadmašiti ogromne modele za uske zadatke.
Što gradimo
Pokazat ću ti kako kreirati prilagođeni jezični model koristeći PyTorch. Naš primjer će se fokusirati na znanje tvrtke MyNextDeveloper, ali možeš to prilagoditi za bilo koju domenu — pravne dokumente, tehničke priručnike, odgovore u korisničkoj službi, bilo što.
Postavljanje tvoje AI radionice
Prvo, pripremimo naše alate. Trebat ćeš Python i nekoliko biblioteka. Ne brini ako nisi stručnjak za kodiranje — objasnitit ću sve korak po korak.
import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt from collections import Counter import re import math
Ako koristiš Google Colab (što preporučujem početnicima), većina toga je već instalirana.
Korak 1: Učenje AI-ja da razumije riječi
Prije nego što naš model može učiti jezik, mora razumjeti što su riječi. Ovaj proces se zove tokenizacija — dijeljenje teksta na dijelove s kojima računalo može raditi.
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)}")
Što se ovdje događa? Kreiramo rječnik gdje svaka jedinstvena riječ dobiva broj. Razmisli o tome kao da svakoj riječi u tvojoj domeni daješ osobnu iskaznicu.
Korak 2: Priprema podataka za obuku
Naš model uči gledajući sekvencije riječi i pokušavajući predvidjeti što dolazi dalje. To je kao da nekoga učiš jezik pokazivanjem milijuna fragmenata rečenica.
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))
To kreira tisuće primjera gdje model vidi sekvencu riječi i uči koja bi riječ trebala doći dalje.
Korak 3: Mozak našeg AI-ja
Sada dolazi uzbudljivi dio — izgradnja stvarne neuronske mreže. Koristimo Transformer arhitekturu, istu vrstu koja pokreće ChatGPT, samo manju.
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)
Ova mreža uči uzorke u jeziku obrađujući sekvencije riječi kroz više slojeva matematičkih transformacija.
Korak 4: Obuka modela
Evo gdje učimo naš model svemu o tvojoj domeni:
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}")
Proces obuke je kao što prikazuješ modelu tisuće primjera i dozvoljavaš mu da postepeno poboljša svoju sposobnost pogađanja.
Korak 5: Stavljanje svega zajedno
Obučimo naš model na informacijama o tvrtki 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)
Korak 6: Testiranje tvoga stvaranja
Kada je obuka dovršena, možeš razgovarati sa svojom prilagođenom AI-jem:
# 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 veza za ovaj članak je ovdje i može se pokrenuti jednim klikom: veza
Upravljanje očekivanjima
Budimo iskreni o onome što dobivaeš. Tvoj prilagođeni model će:
✅ Prednosti:
- Biti potpuno privatne i sigurne
- Raditi bez internetske veze
- Ništa ne koštati nakon obuke
- Biti savršeno prilagođene tvojoj domeni
- Generirati odgovore trenutno
❌ Ograničenja:
- Neće imati opće svjetsko znanje
- Može proizvesti ponavljajuće odgovore
- Zahtijeva kvalitetne podatke za obuku
- Trebalo vremena i truda za pravilnu obuku
- Neće se podudarati s versatiIlnošću GPT-4
Primjene iz stvarnog svijeta
Evo nekih praktičnih upotreba prilagođenih modela:
Usluga korisnicima: Obučite na svojim često postavljanim pitanjima i tiketima podrške za trenutne, dosljedne odgovore.
Tehnička dokumentacija: Kreirajte model koji može odgovoriti na pitanja o vašem specifičnom softveru ili procesima.
Generiranje sadržaja: Generirajte opise proizvoda, predloške e-pošte ili objave na društvenim medijima u vašem brendnom glasu.
Pravno/Sukladnost: Obučite na vašim industrijskih propisima za brzo pretraživanje politike.
Savjeti za obuku koji zaista funkcioniraju
1. Kvaliteta umjesto količine: 1.000 dobro napisanih primjera nadmašuje 10.000 nasumičnih.
2. Budi konzistentan: Ako su tvoji podaci za obuku nekonzistentni, tvoj model će biti i to.
3. Počni maleno: Počni s fokusiranom domenом umjesto pokušaja pokriti sve.
4. Testiraj rano i često: Generiraj odgovore tijekom obuke da uhvatiš probleme rano.
5. Spremi svoje modele: Uvijek spremi obučene modele kako ne bi trebao ponovno obučavati od nule.
Ekonomika prilagođenih modela
Razgovarajmo o troškovima:
Obuka: Ako koristiš oblačne GPU-e, očekuj $5–20 za mali model.
Pokretanje: Potpuno besplatno nakon obuke.
Vremenski ulaganje: Trebalo vremena za izgradnju, zatim uglavnom automatizirано
Održavanje: Može se ažurirati kada se tvoja baza znanja promijeni
Usporedi to s troškovima API-ja: ako radiš tisuće upita mjesečno, prilagođeni model se brzo isplati.
Što može pošao po zlu?
Preobuka: Model zapamti tvoje podatke za obuku ali ne može generalizirati. Rješenje: Koristi raznovrsnije primjere i kraću obuku.
Nepravilna obuka: Model ne uči dovoljno. Rješenje: Obučavaj duže ili koristi više podataka.
Ponavljajući odgovori: Model se zaglavimo u petljama. Rješenje: Prilagodi temperaturu i top-k parametre tijekom generiranja.
Lošia kvaliteta podataka: Smeće unutar, smeće izvana. Rješenje: Proveди vrijeme čišćenja i poboljšanja tvoga teksta za obuku.
Skaliranje
Kada imaš radni model, možda ćeš htjeti:
- Obučiti veće modele s više parametara
- Kombinirati više modela za različite domene
- Implementirati sofisticiranije tehnike generiranja
- Izgraditi jednostavno sučelje za korištenje drugima
Gledajući naprijed
Gradili smo jezični model od nule — nešto što je izgleda nemoguće prije samo nekoliko godina. U našem završnom članku, pokazat ću ti kako povezati tvoje AI alate sa stvarnim svijetom koristeći Model Context Protocol (MCP), pretvarajući ih iz izoliranih sustava u moćne, povezane asistente.
Prilagođeni jezični modeli više nisu samo za tehnološke divove. S pravim pristupom, bilo koja tvrtka može kreirati AI koji zaista razumije njihovu domenu i govori njihovim jezikom. Možda nije GPT, ali je tvoj, i ponekad je to točno ono što ti trebаš.
Dolazi: Članak 5 — "Povezivanje tvog AI-ja sa svijetom: MCP u akciji"
