లోకల్ AI టోకెన్ ఆర్థికశాస్త్రం

ప్రతి పెద్ద క్లౌడ్ ప్రొవైడర్ నేను రాయకూడదని కోరుకునే వ్యాసం ఇదే. లెక్కలు దాగి లేవు: వారి సొంత ధరల పేజీల్లో, వారి సొంత డాక్యుమెంటేషన్‌లో, ఎవరైనా డౌన్‌లోడ్ చేసుకోగల పరిశ్రమ అధ్యయనాల్లో సరళమైన భాషలో ప్రచురితమై ఉన్నాయి. అవి చదవకుండా ఉండిపోవాలని వారు కోరుకుంటారు, ఎందుకంటే లెక్క చూసి సొంత ఇన్ఫరెన్స్ లేయర్‌ను నిలబెట్టుకునే ప్రతి కంపెనీ API అద్దెపై తక్కువ ఖర్చు చేసే కంపెనీ. ప్రతి స్థాయిలో సమాధానం ఒకటే, ఐదుగురి స్టార్టప్, యాభై వేల వినియోగదారుల ఎంటర్‌ప్రైజ్, మధ్యలో ఎక్కడైనా: తన ఇన్ఫరెన్స్ లేయర్‌కు యజమాని అయిన బృందం అద్దెకు తీసుకునే బృందం కంటే అనేక రెట్లు ఎక్కువగా తన ఖర్చును తిరిగి రాబట్టుకుంటుంది.

ఆర్కిటెక్చర్

మిలియన్ టోకెన్లకు రేటు సమతలంగా కనిపిస్తుంది. కాదు. అవుట్‌పుట్ ఇన్‌పుట్‌కు మూడు నుంచి పది రెట్లు. రీజనింగ్ మోడల్స్ తమ చైన్-ఆఫ్-థాట్ టోకెన్లను ఆ అవుట్‌పుట్ బిల్లులోనే దాచేస్తాయి. ప్రతి రిక్వెస్ట్ సిస్టమ్ ప్రాంప్ట్ ఖర్చును, దానికి జతచేసిన ఏ RAG సందర్భాన్నైనా మళ్లీ చెల్లిస్తుంది. వీటిలో ఏదీ ధరల పేజీలో విడిగా చూపబడదు. అన్నీ ఇన్వాయిస్‌పై వచ్చి పడతాయి.

Enterprise Strategy Group 2025లో Dell Technologiesతో కలిసి ఈ పోలిక చేసింది, నాలుగేళ్ల కాలంలో RAGతో 70B-పారామీటర్ Llama 3 డిప్లాయ్‌మెంట్‌ను మూడు ఆర్కిటెక్చర్లపై మోడల్ చేసింది: ఆన్-ప్రెమిసెస్ Dell AI Factory, క్లౌడ్ IaaS, స్వచ్ఛమైన API వినియోగం. అధిక-వినియోగ చివరన లెక్క ఇలా ఉంటుంది:

10,000 వినియోగదారుల వద్ద, నాలుగేళ్ల కాలంలో ఆన్-ప్రెమిసెస్ 52% చవక. 50,000 వినియోగదారుల వద్ద 62% చవక. స్వీకరణతో అంతరం పెరుగుతుంది, ఇది చాలా కొనుగోలు అంచనాల పునాదికి సరిగ్గా వ్యతిరేకం. అదే లెక్కను మీ సొంత వర్క్‌లోడ్‌పై చూడాలనుకుంటే, ఈ సైట్‌లో రెండు తోడు టూల్స్ ఉన్నాయి: LLM కాస్ట్ కాలిక్యులేటర్ మీ నిర్దిష్ట టోకెన్ పరిమాణాలకు ఏ క్లౌడ్ మోడల్‌కు, ఏ లోకల్ హార్డ్‌వేర్ ఎంపికకు మధ్య అయినా బ్రేక్-ఈవెన్ నెలను లెక్కిస్తుంది, హైపర్‌స్కేలర్ ధరల పోలిక అదే మోడల్‌పై Bedrock, Azure Foundry, Vertexలను వారం వారం ధ్రువీకరించిన ధరలతో ట్రాక్ చేస్తుంది.

ఒక్క క్షణం సంపూర్ణ సంఖ్యలను మరచిపోండి. వక్రరేఖలను చూడండి. API ఖర్చు ట్రాఫిక్‌తో సరళరేఖలా పెరుగుతుంది, ఎన్నడూ స్థిరపడదు. సొంత హార్డ్‌వేర్ ఖర్చు హార్డ్‌వేర్ జీవితచక్రం వద్ద ఆగుతుంది. మీరు కందకం తవ్వారా లేక పన్నుపై సంతకం చేశారా అని నిర్ణయించే చలరాశి స్వీకరణ. Dell సంఖ్యలు ఎంటర్‌ప్రైజ్ స్థాయివి, కానీ వక్రరేఖ ఫ్రాక్టల్: ప్రోటోటైప్ నుంచి ప్రొడక్షన్‌కు వెళ్తూ తమ నెలవారీ Anthropic లేదా OpenAI బిల్లు పైకి పాకడం చూస్తున్న ఐదుగురి స్టార్టప్ ఇదే రేఖపై ఉంది, చిన్న గుణకంతో మాత్రమే. లెక్కకు మీ సిబ్బంది సంఖ్యతో పనిలేదు; మీ నిరంతర టోకెన్ పరిమాణం సొంత హార్డ్‌వేర్ ఖర్చు తిరిగి వచ్చేంతగా దాన్ని బిజీగా ఉంచుతుందా అనేదే దానికి ముఖ్యం.

డాలర్ల పోలికలో అసలు కనిపించని రెండో అక్షం ఉంది. క్లౌడ్ ఇన్ఫరెన్స్ ప్రతి ప్రాంప్ట్‌ను, అంటే సిస్టమ్ సందర్భం, తెచ్చిన పత్రాలు, ఏజెంట్ మధ్యంతర స్థితిని, నెట్‌వర్క్ సరిహద్దు దాటించి మూడో పక్షానికి తీసుకెళ్తుంది. దాంతో నిబంధనల అనుపాలన పరిధి, మేధో సంపత్తి లీకయ్యే ప్రమాదం, కాంటెక్స్ట్-విండో రోడ్‌మ్యాప్‌లు, రేట్ లిమిట్ల చుట్టూ వెండర్ లాక్-ఇన్, ప్రొవైడర్‌కు తెల్లవారుజామున 3 AMకి ప్రాంతీయ అంతరాయం వస్తే కేంద్రీకరణ ప్రమాదం, ఒకే మోడల్ అందించే హైపర్‌స్కేలర్ల మధ్య కూడా ధరల వ్యత్యాసం, ఇవన్నీ సక్రియమవుతాయి. దీన్ని నేను ఇన్ఫరెన్స్ సార్వభౌమత్వం అంటాను. ఐదేళ్ల క్రితం టెక్ నాయకత్వం డేటా సార్వభౌమత్వం గురించి చేసిన సంభాషణే ఇది, స్టాక్‌లో ఒక మెట్టు కిందికి.

ఈ దశలో CTOల నుంచి నాకు వచ్చే అభ్యంతరం న్యాయమైనది: “కానీ Bedrock, Vertex, OpenAI అన్నీ ఫైన్-ట్యూనింగ్ ఇస్తాయి. నాకు సొంత GPU ఎందుకు?” ఎందుకంటే క్లౌడ్-నిర్వహిత ఫైన్-ట్యూనింగ్ అంటే అదనపు దశలతో అద్దె. ట్రెయినింగ్ డేటా ఇప్పటికీ మీ సరిహద్దు దాటుతుంది. అడాప్టర్ వెయిట్లు వేరొకరి మౌలిక సదుపాయాలపై ఉంటాయి. ఇన్ఫరెన్స్ ఇప్పటికీ వేరొకరి ప్రతి-రిక్వెస్ట్ రేటుతో, వేరొకరి రోడ్‌మ్యాప్‌కు లోబడి నడుస్తుంది. మీరు ఆధారపడటానికి కస్టమైజేషన్‌ను జోడించారు, ఆధారపడటాన్ని తొలగించలేదు. మీ మోడల్, మీ డేటా, మీ ఇన్ఫరెన్స్ లూప్ ఒకేసారి మీవే అయ్యే ఏకైక ఆర్కిటెక్చర్ లోకల్ ల్యాబ్.

నిర్మాణం

చాలా బృందాలు ఈ అడుగు ఎన్నడూ వేయకపోవడానికి కారణం అవి మీ మోడల్‌కు యజమాని అవడం, మీ మోడల్‌ను మొదటి నుంచి ట్రెయిన్ చేయడం రెండింటినీ కలగలిపేయడమే. ఇవి ఖర్చులో నాలుగు నుంచి ఆరు పరిమాణ క్రమాల తేడాతో వేరైన రెండు పూర్తిగా భిన్న సమస్యలు.

దీన్ని ప్రీ-ట్రెయిన్ చేయకండి

Stanford 2025 AI Index ఫ్రాంటియర్ వెనుక ఉన్న ట్రెయినింగ్ కంప్యూట్ ధరను లెక్కగట్టింది: GPT-4 సుమారు $78 మిలియన్, Llama 3.1 405B $170 మిలియన్, Gemini Ultra $191 మిలియన్. ఇవి క్లౌడ్ అద్దె డాలర్లు, వాయిదాల్లో లెక్కించినవి, కేవలం ముడి కంప్యూట్: డేటా ఇంజినీరింగ్ లేదు, MLOps లేదు, వేల GPUల క్లస్టర్‌ను పాడుచేయకుండా నడపగల వారి జీతాలు లేవు. వక్రరేఖ చిన్న చివరలో కూడా మొదటి నుంచి 7B మోడల్ అంటే $50K–$500K, పదుల వేల GPU-గంటలు. 70Bకి $1.2M–$6M, వారాల పాటు నడిచే ప్రత్యేక 256-GPU H200 క్లస్టర్ కావాలి.

అది చేయకండి. ఫ్రాంటియర్-ల్యాబ్ బడ్జెట్ల బయట ఎవరికీ అది అవసరం లేదు.

బదులుగా PEFT చేయండి

అసలు ఎత్తుగడ ఉన్న ఓపెన్-వెయిట్ బేస్‌పై పారామీటర్-ఎఫిషియెంట్ ఫైన్-ట్యూనింగ్ (Parameter-Efficient Fine-Tuning). Llama 3, Mistral, Qwen, Phi: ఇప్పటికే ఇంగ్లీష్‌లో ధారాళం, వాక్యనిర్మాణంలో సరైనవి, ప్రపంచ జ్ఞానం ఉన్నవి. వాటిపై మీరు జోడించేది మీ రంగం: మీ వర్గీకరణ, మీ ఫార్మాట్, మీ నిర్ణయ తర్కం, మీ స్వరం. పారామీటర్ స్పేస్‌లో ఇది చిన్న సర్దుబాటు, ఆధునిక పద్ధతులు దాన్నే నేరుగా వాడుకుంటాయి.

ఆ VRAM కాలమ్‌లోని సంఖ్యలు 7B మోడల్‌కు ఆధార విలువలు. ఒక నిర్దిష్ట క్వాంటైజేషన్‌లో ఒక నిర్దిష్ట మోడల్ ఒక నిర్దిష్ట GPUలో నిజంగా పడుతుందా అని తేల్చడానికి GPU VRAM కాలిక్యులేటర్ దాన్ని విడగొట్టి చూపుతుంది: మోడల్ వెయిట్లు, KV కాష్, యాక్టివేషన్లు, కన్స్యూమర్ GPUలు, డేటాసెంటర్ కార్డులు, Apple Silicon, Pi యాక్సిలరేటర్ల ఎంపిక చేసిన పట్టికతో పోల్చి. ఏ హార్డ్‌వేర్ నిర్ణయానికైనా ముందు నడిపి చూడదగినది.

LoRA బేస్ వెయిట్లను పూర్తిగా స్తంభింపజేసి, నిర్దిష్ట అటెన్షన్ లేయర్లలో చిన్న శిక్షణీయ ర్యాంక్-డికంపోజిషన్ మ్యాట్రిక్స్‌లను ప్రవేశపెడుతుంది: మీరు పారామీటర్ సంఖ్యలో సుమారు 1% స్థాయిలో ఏదో నవీకరిస్తున్నారు. QLoRA స్తంభింపజేసిన బేస్‌ను 4-బిట్‌కు క్వాంటైజ్ చేసి మరింత ముందుకెళ్తుంది, దాంతో మెమరీ పాదముద్ర చాలా తగ్గి 7B ఫైన్-ట్యూన్ ఒక కన్స్యూమర్ GPUపై పడుతుంది. QLoRAపై తీవ్రమైన అనుసరణ రన్ కొన్ని వందల డాలర్లలో ముగిసి రాత్రికి రాత్రే పూర్తవుతుంది. స్క్రిప్ట్ ఆకారం, అంటే ఎంపిక చేసిన డేటాసెట్‌పై Gekro ల్యాబ్ పని వచ్చే త్రైమాసికంలో ప్రణాళిక చేయబడినది, ఇంచుమించు ఇలా ఉంటుంది:

# gekro_qlora_train.py - Llama 3 8B + QLoRA via Unsloth + TRL
# Target: single consumer GPU (Mac Mini Metal or RTX 4090 class)
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3-8b-bnb-4bit",
    max_seq_length=4096,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,                                # LoRA rank
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    lora_dropout=0.0,
    use_gradient_checkpointing="unsloth",
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    # Expected JSONL shape per record:
    # {"messages": [{"role": "user", "content": "..."},
    #               {"role": "assistant", "content": "..."}]}
    train_dataset=load_curated_dataset(),    # your domain corpus
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        optim="adamw_8bit",
        output_dir="./checkpoints",
    ),
)
trainer.train()

ఒక ఫైల్. ఒక GPU. ఒక రాత్రి రన్. అవుట్‌పుట్ ఒక చిన్న అడాప్టర్ వెయిట్ ఫైల్, దాన్ని మీరు ఇన్ఫరెన్స్ సమయంలో స్తంభింపజేసిన బేస్‌పై లోడ్ చేసి, బేస్ మోడల్‌ను ఎలా సర్వ్ చేస్తారో అలాగే Ollama లేదా vLLMతో సర్వ్ చేస్తారు.

హార్డ్‌వేర్ స్థాయిలు: ల్యాబ్‌లు బృందం పరిమాణంతో పెరుగుతాయి, కంపెనీ ఆదాయంతో కాదు

భారీ AI వర్క్‌ఫ్లోలు నడిపే ఒంటరి ఇంజినీర్ స్థాయి 1కి చెందుతాడు. నిరంతర ఏజెంటిక్ వర్క్‌లోడ్లు నడిపే బృందం స్థాయి 2కు చెందుతుంది. వేలాది వినియోగదారులకు సేవ చేసే సంస్థ స్థాయి 3కు చెందుతుంది. అదే ఆర్కిటెక్చర్, మూడు గుణకాలు. ప్రతి స్థాయిలో ఖర్చు తిరిగి రాబట్టే లెక్క దాన్ని ఆమోదించిన కొనుగోలు చక్రం కంటే వేగంగా ఉంటుంది: స్థాయి 1లో నెలలు, ఫైన్-ట్యూన్ చేసిన అడాప్టర్లు నిజమైన ట్రాఫిక్‌కు సేవ చేయడం మొదలుపెట్టాక స్థాయి 2లో వారాలు, నిరంతర స్థాయిలో సమానమైన API ఖర్చుతో పోలిస్తే స్థాయి 3లో అనేక రెట్లు.

2026లో సర్వింగ్ స్టాక్ ఒకే చోటికి చేరింది, ఇదే కథలో తక్కువగా చెప్పబడిన భాగం. vLLM త్రూపుట్‌లో గెలిచింది: దాని PagedAttention అల్గారిథమ్ ఆపరేటింగ్ సిస్టమ్‌లు వర్చువల్ మెమరీని పేజ్ చేసినట్టే KV కాష్‌ను విభజిస్తుంది, అదే హార్డ్‌వేర్‌పై vLLMతో సర్వ్ చేయడానికి, అమాయకంగా సర్వ్ చేయడానికి మధ్య తేడా ఖాళీగా ఉన్న GPUకి, నిండుగా ఉన్న GPUకి మధ్య తేడా. Ollama డెస్క్‌టాప్, ఎడ్జ్ కోసం డెవలపర్ సౌలభ్యంలో గెలిచింది. మీరు NVIDIAకి కట్టుబడి ప్రతి చివరి సైకిల్ కావాలనుకునే చోట TensorRT-LLM ఉంటుంది. ప్రయోగాల ట్రాకింగ్‌ను MLflow లేదా Weights & Biases చూసుకుంటాయి, ఎందుకంటే LLM ఫైన్-ట్యూనింగ్ నాన్-డిటర్మినిస్టిక్, అందుకే పరిశోధన డెమోకు, ప్రొడక్షన్ సిస్టమ్‌కు మధ్య తేడా పునరుత్పత్తి సామర్థ్యమే.

పెద్ద స్థాయిలో ప్రొడక్షన్ ఇన్ఫరెన్స్ నడపడానికి ఇకపై మీకు Anthropic లేదా OpenAI మౌలిక సదుపాయాల బృందం అవసరం లేదు. ఆ కంపెనీలు నిర్మించడానికి సంవత్సరాలు పట్టిన స్టాక్ ఇప్పుడు ఒక pip install, ఒక కాన్ఫిగ్ ఫైల్. ఇది 2026లో కొత్త, ఈ పోస్ట్‌లోని లెక్క ప్రతి స్థాయిలో పనిచేయడానికి పూర్తి కారణం ఇదే. నేను ఇప్పటికే నిర్మాణపరమైన బీమాగా Piపై Ollama నమూనాను, క్లౌడ్, లోకల్ ప్రొవైడర్లను ఒకే ఇంటర్‌ఫేస్ వెనుక అబ్‌స్ట్రాక్ట్ చేసే GekroLLMClientను నమోదు చేశాను; రెండూ హోమ్ ల్యాబ్ నుంచి నేరుగా ఎంటర్‌ప్రైజ్ స్థాయికి విస్తరిస్తాయి.

రాజీలు

ఇన్ఫరెన్స్ లేయర్‌ను సొంతం చేసుకోవడం ఉచితం కాదు, లేదన్నట్టు నటించడమే ల్యాబ్‌లను పేపర్‌వెయిట్‌లుగా మారుస్తుంది. పేరు పెట్టదగిన నాలుగు వైఫల్య తీరులు ఉన్నాయి.

తక్కువ వినియోగం వక్రరేఖను చంపేస్తుంది. బ్రేక్-ఈవెన్ వాదన నిరంతర త్రూపుట్‌పై ఆధారపడుతుంది. స్థాయి-3 సర్వర్‌ను నిలబెట్టి 8% వినియోగంతో నడిపితే మీరు చాలా ఖరీదైన పేపర్‌వెయిట్ నిర్మించారు. క్లౌడ్ APIలు ఎగుడుదిగుడు, తక్కువ-పరిమాణ పనికి నిజంగా చవక: అదే వాటికి సరిపోయే ఆకారం, అందుకోసం వాటిని వాడుతూనే ఉండాలి. ఏ హార్డ్‌వేర్ నిర్ణయానికైనా ముందు అడగండి: నేను లోపలికి తెస్తున్న వర్క్‌లోడ్ల స్థిర రోజువారీ టోకెన్ పరిమాణం ఎంత, హార్డ్‌వేర్‌ను బిజీగా ఉంచేంత పెద్దదా? నిజాయితీ సమాధానం కాదు అయితే ఆ వర్క్‌లోడ్‌కు APIపైనే ఉండండి. లోకల్ హార్డ్‌వేర్ నిండుగా ఉన్నప్పుడే తన అన్నం సంపాదిస్తుంది.

క్వాలిటీ క్లిఫ్ నిజమే. ఇరుకైన, బాగా నిర్వచించిన పనిపై ఫైన్-ట్యూన్ చేసిన 8B ఆ పనిలో ఫ్రాంటియర్ APIతో సరితూగగలదు లేదా దాన్ని మించగలదు: ఫైన్-ట్యూనింగ్ మొత్తం ఉద్దేశ్యం అదే. కానీ వర్క్‌లోడ్ ఓపెన్-ఎండెడ్ రీజనింగ్ లేదా బహు-రంగ జ్ఞానం వైపు జారగానే చిన్న మోడల్ ఆ క్లిఫ్ నుంచి పడిపోతుంది. నేను దీన్ని నేరుగా అనుభవించాను. నా Mac Mini సంతోషంగా క్వాంటైజ్డ్ 70Bని నడుపుతుంది, సమాధానాలు సారాంశం, వర్గీకరణ, కోడ్ రివ్యూకు పూర్తిగా ఉపయోగపడతాయి. అవి అదే ప్రాంప్ట్‌కు Claude లేదా Gemini Pro ఇచ్చే వాటికంటే స్పష్టంగా తక్కువ సూక్ష్మంగా కూడా ఉన్నాయి: చిన్నవిగా, మరింత అక్షరార్థంగా, ప్రశ్న రెండో స్థాయి అంతరార్థాన్ని విడిచిపెట్టే అవకాశం ఎక్కువగా. రూటింగ్ నిర్ణయమే ఆర్కిటెక్చర్, అది క్లయింట్ రాపర్‌లో ఉంటుంది:

# Hybrid routing - local for narrow tasks, cloud for long-tail reasoning
NARROW = {"classify", "extract", "summarize", "format", "tag"}
REASONING = {"design", "plan", "synthesize", "debug-novel"}

def route(task_class: str, prompt: str) -> str:
    if task_class in NARROW:
        return local_finetuned_8b.run(prompt)
    if task_class in REASONING:
        return cloud_frontier.run(prompt)
    return cloud_frontier.run(prompt)        # default: don't guess

ఇరుకైన, అధిక-పరిమాణ, లేటెన్సీ-సున్నితమైన పనికి లోకల్. లోకల్ మోడల్ నిర్వహించలేని లాంగ్-టెయిల్ రీజనింగ్‌కు క్లౌడ్ ఫ్రాంటియర్. ఇదే API సార్వభౌమత్వ నమూనా హృదయం: ల్యాబ్ క్లౌడ్‌ను భర్తీ చేయదు, ముందుగా ఊహించదగిన వర్క్‌లోడ్లను తినేస్తుంది. లోకల్ స్థాయి నిర్వహించే ప్రతి టోకెన్ క్లౌడ్ ఇన్వాయిస్ మీకు బిల్ చేయని టోకెన్. మీరు క్లౌడ్‌లో ఉంచే ప్రతి టోకెన్ ద్వారా ఆచరణలో ప్రొవైడర్ తదుపరి ట్రెయినింగ్ కంప్యూట్‌కు మీరు సబ్సిడీ ఇస్తున్నారు.

కందకం డేటాసెట్, GPU కాదు. కంప్యూట్ చవక. GPU సమయంలో $300 ఖర్చయ్యే QLoRA రన్ నిపుణుల గంటల్లో బృందానికి $60,000 ఖర్చయిన ఎనోటేషన్ శ్రమపై ఆధారపడి ఉండవచ్చు, తీవ్రమైన DPO లేదా RLHF రన్‌లో మానవ-లేబులింగ్‌కు కంప్యూట్‌కు నిష్పత్తి మనుషుల వైపు ఇరవై నుంచి ముప్పై రెట్లు ఉండటం సాధారణం. ఇది ఫైన్-ట్యూనింగ్‌కు వ్యతిరేకంగా వాదన కాదు. మీ సంస్థ తన వర్గీకరణను రాతపూర్వకంగా చెప్పలేకపోతే, మీ రంగానికి సరైన అవుట్‌పుట్ ఎలా ఉంటుందో అంగీకరించలేకపోతే, ఎనోటేషన్ సమీక్షకు రంగ నిపుణులను కేటాయించలేకపోతే, మీకు ఇంకా ఫైన్-ట్యూనింగ్ సమస్య లేదు, జ్ఞాన నిర్వహణ సమస్య ఉంది అనే వాదన ఇది. ముందు దాన్ని పరిష్కరించండి. కంప్యూట్ సులభమైన సగం. ట్రెయినింగ్ ఉదాహరణలను ఫార్మాట్ చేయడం మొదలుపెట్టినప్పుడు ఫ్రేమ్‌వర్క్‌ల మధ్య ఫార్మాట్ ఘర్షణ ఆశించండి: OpenAI చాట్ స్కీమా, Alpaca, ShareGPT, Unsloth/Llama అన్నీ అదే డేటాను కొంచెం భిన్నంగా కోరుకుంటాయి. మార్పిడిని నిర్వహించడానికి, నిశ్శబ్దంగా ట్రెయినింగ్ విఫలం చేసే తప్పిపోయిన-టర్న్ లోపాలను గుర్తు పెట్టడానికి నేను ఫైన్-ట్యూనింగ్ డేటాసెట్ ఫార్మాటర్ నిర్మించాను.

హార్డ్‌వేర్ పునరుద్ధరణ క్రూరమైనది. అదే లక్షణం, లోపం కాదు. అకౌంటింగ్ సర్వర్ల తరుగును ఐదు లేదా ఆరు ఏళ్లలో లెక్కిస్తుంది. AI సిలికాన్ సహకరించదు. కొత్త GPU తరాలు దాదాపు ప్రతి సంవత్సరం గణనీయమైన సామర్థ్య లాభాలతో వస్తాయి, అంటే 2024 ఆరంభంలో కొన్న H100 2026 చివరికి రెండు ఆర్కిటెక్చర్ తరాల వెనుక ఉంటుంది. అత్యంత డిమాండ్ ఉన్న స్థాయిలో 24–36 నెలల పునరుద్ధరణను, పాత సిలికాన్‌ను తేలికైన వర్క్‌లోడ్లకు దించే విలువ-క్యాస్కేడ్ నమూనాను ప్రణాళిక చేయండి: 1–2 సంవత్సరాల్లో ఫ్రాంటియర్ ట్రెయినింగ్, 3–4 సంవత్సరాల్లో రియల్-టైమ్ ఇన్ఫరెన్స్, ఆ తర్వాత బ్యాచ్ అనలిటిక్స్. దూకుడుగా పునరుద్ధరించే సౌలభ్యమే ఒక వ్యూహాత్మక ఆస్తి. క్లౌడ్ మూడేళ్ల రిజర్వ్డ్-ఇన్‌స్టెన్స్ నిబద్ధత అది ఇవ్వదు, మీ ఫైనాన్స్ బృందం సంతకం చేయబోతున్న దీర్ఘకాలిక API ఒప్పందం కూడా ఇవ్వదు.

ఇది ఎటు వెళ్తుంది

ఈ పోస్ట్ కొంత సంశ్లేషణ, కొంత నా సొంత రోడ్‌మ్యాప్. ఈరోజు నేను Mac Mini, Pi క్లస్టర్‌పై లోకల్ ఇన్ఫరెన్స్ నడుపుతున్నాను, GekroLLMClient వర్క్‌లోడ్ తరగతిని బట్టి క్లౌడ్, లోకల్ మధ్య రూట్ చేస్తుంది. నేను ఇంకా చేయనిది, ల్యాబ్ పని వచ్చే త్రైమాసికం దేని చుట్టూ నిర్మించబడిందో అది, నా సొంత హార్డ్‌వేర్‌పై ఎంపిక చేసిన డేటాసెట్‌తో మొదటి నుంచి చివరి వరకు QLoRA నడపడం, ఒక్కసారి చేసిన ఫైన్-ట్యూన్‌ను పునరుత్పాదక పైప్‌లైన్‌గా మార్చే eval లూప్, MLOps క్రమశిక్షణతో. నేను నివసించే చోటికి ప్రత్యేకమైన రెండో ఆప్టిమైజేషన్ ఉపరితలం కూడా ఉంది: ట్రెయినింగ్ జాబ్‌లు ఎప్పుడు నడవాలనే దానిపై Texas గ్రిడ్‌కు సొంత అభిప్రాయాలు ఉన్నాయి, హార్డ్‌వేర్ ముందుగా మీ సొంతమైనప్పుడే అది తెరుచుకుంటుంది.

ఇందులో ఏదీ దాగి లేదు. మీ నెలవారీ ఇన్వాయిస్ రాసే క్లౌడ్ ప్రొవైడర్లకు ఇది ఇప్పటికే తెలుసు. మీ ఇంజినీరింగ్ బృందం ఫీచర్లు పంపడంలో ఎంతగా నిమగ్నమై ఉందంటే లెక్క వేయదని వారు పందెం కడుతున్నారు. అయినా లెక్క వేయండి.