LLM (големи јазични модели) разглобено до последен атом

[Fatal1ty_]

Со развојот на вештачката интелегенција се почесто слушаме и за терминот LLM (големи јазични модели), но дали знаме што значат, за што се користат и како се изградени?

И да знаете и да не знаете не е страшно пошто сеа ќе ја обработиме тематиката по нашки, со народен јазик секој да разбере, на наш македонски јазик...

Што е LLM?

Вештачката интелигенција се повеќе влегува во нашиот живот и нуди се повеќе можности што им се достапни на обичните корисници. Нашиот живот веќе не можеме да го замислиме без LLM (Large Language Models) или големи јазични модели, кои веќе се користат во најразлични области. Тука спаѓаат генерирањето и обработката на текст и код, разговорната вештачка интелигенција (чат-ботови, виртуелни асистенти), машинскиот превод и машинскиот вид, автоматизацијата на деловните процеси и слично.

На крајот на краиштата, LLM овозможуваат значително да се зголеми продуктивноста при извршување на различни задачи. Она што порано можело да одземе денови, па дури и недели рачна работа, сега со помош на LLM се завршува за неколку часа или дури минути. Големите јазични модели станаа толку незаменлива алатка што некои луѓе веќе не можат да ја замислат својата работа без нив.

LLM претставуваат класа на невронски модели на вештачка интелигенција, обучени врз огромни количини податоци (big data). Нивната клучна способност е да разбираат, анализираат и генерираат текстови на природен јазик. Некои LLM работат и со слики, аудио и други видови информации.

Иако невронските мрежи се измислени одамна, вистинскиот пресврт во јавната свест се случи во 2022 година со објавувањето на чат-ботот ChatGPT, кој беше наменет за обичниот корисник, беше достапен бесплатно и на крајот предизвика голем одек во медиумите.

Како се изградени и како работат LLM

Во основата на повеќето современи LLM лежи архитектурата на трансформери (Transformer), претставена во 2017 година. Клучната особина на трансформерите е механизмот на внимание (attention mechanism): тој и овозможува на моделот да ја процени важноста на различните зборови во реченицата еден во однос на друг. Благодарение на ова, моделот ги зема предвид не само најблиските зборови, туку и врските меѓу елементите на текстот што се наоѓаат далеку еден од друг.

Работата на LLM се заснова на предвидување на токени чекор по чекор. Токенот претставува дел од текст: збор, дел од збор или знак. Моделот го анализира контекстот и пресметува кој токен со најголема веројатност треба да следува понатаму. При тоа, тој не го „разбира“ значењето како човек, туку работи со статистички етапи.

Процесот на работа може да се подели на следниве фази:

• Токенизација: барањето на корисникот се дели на одделни токени.
• Векторизација (создавање ембединзи): токените се претвораат во нумерички вектори што го одразуваат нивното значење и контекст.
• Обработка со трансформер: векторите поминуваат низ многу слоеви на моделот, каде што се откриваат скриените зависности и етапи.
• Генерирање одговор: моделот последователно ги предвидува токените и го формира конечниот текст. Процесот завршува кога ќе се генерира посебен токен „крај на реченицата“.

Треба да се разбере дека LLM не е пребарувач. Пребарувачот дава линкови до туѓи сајтови. Моделот, пак, создава нова, уникатна содржина за вашата конкретна задача.

Главната вештина при работата со LLM е умеењето правилно да се формулира задачата (промптот). Колку попрецизно го опишете контекстот, улогата и посакуваниот резултат, толку поквалитетен ќе биде одговорот на моделот.

Ограничувања и проблеми кај LLM

И покрај импресивните можности, LLM имаат низа ограничувања:

• „Халуцинации“: моделот може да дава веродостојни, но лажни одговори.
• Пристрасност: во одговорите може да се појават предрасуди што се содржани во податоците за обука.
• Ограничена контекстна рамка: моделот не може да земе предвид премногу голем обем информации одеднаш.
• Чувствителност на формулациите: мала промена во барањето може силно да влијае на резултатот.
• Застарени податоци: знаењата на моделот се ограничени на периодот во кој е обучен (заостанувањето може да изнесува половина година или повеќе).
• Високи трошоци: обуката и работата на големите модели бараат значителни ресурси.

Разновидност на LLM

Денес под терминот LLM се кријат како модели од општ карактер, така и мноштво специјализирани алатки. Сите тие може да се поделат во пет клучни категории според видот на содржината со која работат:

• Текстуални модели од општа намена (LLM)
  Тоа се класичните чат-ботови или „паметни соговорници“. Тие најдобро се справуваат со текст, програмски код, логичко расудување и анализа на големи количини податоци. Тука спаѓаат:
  • ChatGPT од OpenAI: најпопуларниот и најуниверзалниот модел во светот. Идеален е за основни задачи, креативно пишување и програмирање.
  • Claude од Anthropic: главниот конкурент на ChatGPT.
  • DeepSeek: кинески текстуален модел. Главен конкурент на двата од погоре.
• Генератори на слики (Text-to-Image)
  Овие модели претвораат текстуален опис (промпт) во готови илустрации, фотографии или дигитална уметност. На пример:
  • Midjourney: светски лидер во областа на фотореализмот и уметничките илустрации.
  • DALL-E 3: модел од компанијата OpenAI.
  • Stable Diffusion: модел со отворен изворен код. Овозможува целосна контрола врз процесот на генерирање, но бара моќен компјутер и инсталација.
• Генератори на видео (Text-to-Video)
  Алатки способни да создаваат реалистични видеа според текстуален опис или да оживеат статична слика:
  • Runway (Gen-2 / Gen-3): моќна комерцијална алатка за генерирање кинематографско видео, честопати користена од професионални монтажери.
  • Luma Dream Machine: современа невронска мрежа што создава висококвалитетни 3D-сцени и видеа со реалистична физика на движењето.
  • Sora од OpenAI: напредна апликација што умее да генерира сложени сижејни видеа со прецизно задржување на ликовите и на аглите на снимање.
• Генератори на музика и звук (Text-to-Audio)
  Модели што пишуваат целосни песни со вокал, аранжман и стихови, врз основа на краток опис на жанрот и темата.
  • Suno AI: создава готови радио-хитови за 30 секунди. Вие ја задавате темата, а невронската мрежа сама го пишува текстот и генерира вокал на кој било јазик.
  • Udio: главниот конкурент на Suno, кој се издвојува со неверојатно чист квалитет на звукот и реалистични гласови.
• Локални и тесно специјализирани модели
  Модели што се создаваат за решавање конкретни задачи (на пример, само за пишување код) или се оптимизирани за работа без интернет. На пример, v0 од Vercel е специјализирана невронска мрежа за веб-развивачи, која според текстуален опис веднаш генерира готов интерфејс на сајт (код на React/HTML/CSS).

Стартување на LLM

Начините за стартување на големите јазични модели (LLM) се делат на две основни категории: облачни сервиси (готови решенија преку API) и локално стартување (на сопствена опрема).

Некои од најпопуларните добавувачи на модели нудат готови облачни сервиси, каде што големите јазични модели се веќе поставени. Доволно е да користиме посебен интерфејс за да им пристапиме. Тоа е најлесниот и најбрзиот начин, кој не бара моќен хардвер ниту управување со инфраструктура. Но во овој водич нас ќе не интересира токму локалното стартување на модели на сопствениот компјутер.

За стартување на LLM на домашен компјутер или лаптоп постојат неколку начини. Изборот зависи од тоа дали ви треба готов чат, интеграција во код или максимална заштеда на меморија. Некои од начините претставуваат готови апликации со графички интерфејс или веб-интерфејс за работа преку прелистувач. Распространети начини се:

• LM Studio
  Претставува графичка програма што е доволно да ја преземете од официјалниот сајт, да ја инсталирате и да ја стартувате. Таа ви овозможува да пронајдете одреден модел (се користи складиштето Hugging Face). Доволно е со еден клик да го преземете моделот и можете да разговарате со него.
  Има вграден локален сервер, па може да се поврзе со други програми.
  Ова е всушност најлесниот начин. Инсталација со еден клик, интерфејс сличен на ChatGPT. Одлично одговара за обичните корисници.
• an.ai
  Аналог на LM Studio, исто така претставува графичка апликација, само што за разлика од LM Studio има целосно отворен код (Open-Source). Умее да работи со локални датотеки (RAG), можете да поставите PDF-документ и да разговарате за неговата содржина.
• GPT4All
  Програма од компанијата Nomic. Специјализирана е за работа дури и на слаби процесори без графичка картичка. Многу е лесна и добро оптимизирана за обичните процесори (CPU).
• Ollama
  Се инсталира како конзолна алатка. Работи во заднина како служба и по правило е достапна само преку конзола: за инсталирање и стартување на моделите се користат конзолни команди. Сепак, честопати до Ollama се пристапува преку прелистувач. За таа цел обично дополнително се презема Open WebUI (интерфејс визуелно идентичен со ChatGPT) или AnythingLLM.
  Од предностите може да се спомене дека Ollama троши минимум ресурси кога мирува и управува со меморијата автоматски (префрла делови од моделот меѓу GPU и RAM).
  За обичните корисници Ollama можеби претставува малку посложена варијанта од LM Studio, но сепак не е тешка за користење. Затоа сосема одговара за развивачи и напредни корисници.
• llama.cpp
  Ова е темелот врз кој се изградени LM Studio и Ollama. Сепак, во чиста форма е наменет за понапредни корисници и развивачи, за кои е важна можноста за пофино прилагодување, конфигурирање и управување. На пример, ако моделот треба да се вгради во сопствена скрипта на Python, Node.js или да се автоматизираат задачи. llama.cpp е напишан во чист C/C++ и се одликува со максимална брзина на работа на процесори (вклучувајќи Apple Silicon M1/M2/M3/M4) и графички картички. Има Python-биндинзи (llama-cpp-python), кои овозможуваат лесно да се вклучи овој мотор во сопствените програми.
• Hugging Face Transformers
  Овој начин е наменет за развивачи. Тоа е класична библиотека на Python за работа со невронски мрежи директно преку код. Одговара за длабоко прилагодување, експерименти и дообучување. Работи со не компресирани модели (форматот Safetensors), поради што бара огромен обем чиста видео меморија (VRAM). За обичните компјутери во моментов ретко се користи.

Параметри на моделите и типови модели

Што е „параметар“ кај LLM?

Ако замислите невронска мрежа како огромен дигитален мозок, тогаш параметрите се синапсите (врските меѓу невроните). Физички, секој параметар е едноставно број (коефициент или „тежина“) што определува колку силно еден неврон влијае врз друг при преносот на информации. Кога моделот се обучува, тој ги прилагодува овие броеви. Кога моделот одговара на прашање на корисникот, тој го пропушта текстуалното барање низ овие милијарди броеви (ги множи и ги собира). Колку попрецизно се прилагодени овие броеви и колку повеќе се на број, толку посложени логички врски може да гради моделот.

Буквата „B“ во името на моделите (на пример, Llama-3-8B) означува Billion (милијарда). Тоа значи дека во Llama 3 има 8 милијарди вакви броеви-коефициенти.

Класификација на LLM според бројот на параметри

Во зависност од бројот на параметри (тежини), современите текстуални модели се делат на четири основни групи:

• Микро-модели (до 4B параметри) Најкомпактните мрежи, создадени специјално за работа на смартфони, слаби лаптопи и канцелариски компјутери. Примери: Microsoft Phi-3 (3.8B), Google Gemma 2 (2B), Qwen 2.5 (1.5B и 3B). Ваквите модели имаат основно разбирање на јазикот, можат правилно да поправаат грешки, да прават краток извадок (summary) од текстови и да одговараат на едноставни прашања. Сепак, тие слабо се справуваат со сложена логика, математика, програмирање и долги низи расудување. Честопати „халуцинираат“ (измислуваат факти).
• Мали / основни модели (7B – 14B параметри) Овие модели претставуваат таканаречен „златен стандард“ на open-source индустријата. Идеална рамнотежа меѓу квалитетот на одговорите и системските барања. Примери: Mistral (7B), Llama 3 (8B), Qwen 2.5 (14B), Gemma 2 (9B). Имаат целосно „разбирање“ на контекстот. Добро пишуваат програмски код, одлично преведуваат меѓу јазиците и можат да следат сложени повеќечекорни инструкции (System Prompts). Но на длабоки специјализирани теми (медицина, право) или на заплеткани логички задачи може да прават грешки.
• Средни / професионални модели (30B – 35B параметри) Тешка артилерија за напредни развивачи и ентузијасти. Бараат моќен хардвер. Примери: Yi-34B, Command R (35B), Qwen 2.5 (32B). Покажуваат ниво на логика блиско до комерцијалните затворени модели. Одлично работат со огромни текстови (цели книги) и сложени бази на знаење (RAG-системи). Речиси не прават глупави грешки во кодот.
• Големи / флагмански модели (70B+ параметри) Максимално ниво на интелигенција што е достапно за локално стартување или што го користат големите ИТ-компании. Примери: Llama 3 (70B), Qwen 2.5 (72B). Оваа класа модели има експертски знаења во повеќето области, способна е да решава сложени математички задачи, да пишува архитектура на големи програми и да води длабок аналитички разговор.

Има, се разбира, и исклучоци. Така, денес може да се сретнат модели како Mixtral 8x7B. Формално, во него има околу 47 милијарди параметри. Архитектура MoE, Mixture of Experts.

Квантизација / компресија на LLM

Квантизацијата (Quantization) е уште еден атрибут на моделот што треба да се земе предвид при работата со LLM. Квантизацијата претставува процес на намалување на големината на моделот преку снижување на прецизноста на броевите од кои се составени неговите параметри. Поедноставно кажано, тоа е претворање на тежините на моделот од формат со „висока прецизност“ (каде што секој број е запишан како децимален) во формат на „заокружени броеви“ (каде што децималите стануваат пократки или се претвораат во цели броеви). Ова овозможува моделот да се компресира 2 до 4 пати, при што се задржува до 95 до 99 отсто од неговата првобитна „интелигенција“.

Може да се направи и следнава споредба со пиксели и боја. Да претпоставиме дека секој пиксел од сликата во максимален квалитет се кодира со 16 бита (65.536 нијанси). Ако сликата се компресира на 4 бита (само 16 бои), сликата ќе стане груба. Но кај LLM квантизацијата работи попаметно (благодарение на сложените алгоритми за оптимизација): таа ги наоѓа најважните „нијанси“ (тежини) и ја задржува нивната прецизност, а помалку важните ги заокружува. На крајот моделот тежи многу помалку, а неговата логика речиси и да не страда.

Формати на податоци: од FP16 до INT4

Првично, моделите се обучуваат и се објавуваат во висок квалитет. За да се разберат типовите на квантизација, важно е да се знаат основните формати:

• FP16 / BF16 (16 бита): стандарден формат по правило. Секој параметар зафаќа 2 бајти. Модел од 8B тежи околу 16 GB.
• INT8 (8 бита): тежините се претвораат во цели броеви. Моделот се компресира точно 2 пати. Квалитетот опаѓа незабележливо (во рамки на 1 отсто). Модел од 8B тежи околу 8 GB.
• INT4 / FP4 (4 бита): најпопуларниот формат за домашно стартување. Моделот се компресира 4 пати. Модел од 8B тежи околу 4,5 до 5 GB и лесно се сместува во графичка картичка од 8 GB. Загубата на квалитет изнесува само 1 до 3 отсто.
• INT2 / INT3 (2 до 3 бита): екстремна компресија. Моделот станува многу лесен, но почнува силно да „затапува“, да меша зборови и да губи логика. Ретко се користи.

Основни типови и технологии на квантизација

Во зависност од тоа на каков хардвер и преку кој софтвер ја стартувате невронската мрежа, се користат различни технологии на квантизација.

GGUF (порано GGML), стандард за CPU + GPU

Најфлексибилниот формат, оптимизиран за работа на обични компјутери преку процесори и графички картички (главно преку програмата llama.cpp и интерфејси како LM Studio). Овозможува моделот делумно да се префрли во оперативната меморија (RAM) ако во графичката картичка (VRAM) снема место.

Во имињата на датотеките на моделите со ваква компресија може да се видат ознаки како Q4_K_M, Q5_K_S, Q8_0:

• Q4_K_M (4 бита, среден метод): „златен стандард“. Идеална рамнотежа меѓу големината и интелигенцијата на моделот.
• Q5_K_M (5 бита): малку попаметен, малку потежок. Се препорачува ако имате доволно меморија.

EXL2 / GPTQ, стандард за максимална брзина на GPU

Формати создадени исклучиво за графички картички NVIDIA. Моделот целосно се вчитува во VRAM.

Во имињата на датотеките на моделите се среќаваат ознаки како 4bit, 8bit или точна назнака за битрејтот (на пример, 4.0bpw, што значи „bits per weight“, односно битови по тежина).

Моделите во ваков формат работат повеќекратно побрзо од GGUF, бидејќи ја користат целата моќ на тензорските јадра на графичката картичка. Но ако моделот не се смести целосно во VRAM, тој едноставно ќе даде грешка и нема да се стартува.

AWQ (Activation-aware Weight Quantization), паметна компресија

Напреден метод на квантизација за GPU: при компресијата, алгоритмот анализира кои параметри на моделот најчесто се „вклучуваат“ за време на работата (активации). Овие важни параметри се оставаат во висок квалитет, а останатите се компресираат посилно. AWQ-моделите работат попрецизно од GPTQ при иста големина.

FP4 / NormalFloat4 (NF4), нова генерација

Формати што се користат при дообучување на моделите (QLoRA) и активно се воведуваат во новиот хардвер (на пример, во архитектурата Blackwell кај RTX 5090). Математички, овој формат е подобро прилагоден за распределбата на тежините во невронските мрежи отколку обичниот INT4, што ја намалува загубата на прецизност речиси до нула.

Општи забелешки

Ако преземате модел за лична употреба, тогаш подобро е да барате модел со тип Q4_K_M (во формат GGUF) или 4bit (во формат AWQ/EXL2). Ова ќе ви овозможи да добиете модел што е 4 пати помал од оригиналот, работи 3 до 4 пати побрзо, а разликата во квалитетот на одговорите најверојатно нема ни да ја забележите.

Токен и токенизација

Токенот (во контекст на моделите LLM) е основна единица текст што моделот ја користи за читање, обработка и генерирање информации. Невронските мрежи не ги разбираат човечките зборови во целост, а уште помалку ги гледаат одделните букви. Тие го претвораат текстот во броеви. Процесот на разбивање на текстот на вакви делчиња (токени) се нарекува токенизација, а алатката што го прави тоа се нарекува токенизатор (Tokenizer).

Токенот не е задолжително цел збор. Тоа може да биде:

• Дел од збор (слог или корен)
• Цел збор (ако е краток или често се среќава)
• Еден знак или интерпункциски знак (запирка, празно место, емоџи)

Различните модели може различно да ги разбиваат зборовите на токени. Да разгледаме пример на англиски јазик. Зборот „unbelievable“ токенизаторот може да го разбие на три дела: ["un", "believ", "able"]. Секој дел е одделен токен.

Сега да земеме пример на македонски јазик. Во македонскиот јазик, поради сложената морфологија и наставките, зборовите се разбиваат на токени уште посилно. Зборот „Здраво“ ќе се претвори во ["З", "драв", "о"] (3 токени).

Компанијата OpenAI дури објави и бесплатна алатка за пресметка на токени, OpenAI Tokenizer, која овозможува нагледно да се види како одредена фраза се разбива на токени.

На пример, да ја земеме фразата "I love programming". Тука има три збора, а секој од нив, од гледна точка на LLM GPT-5, претставува одделен токен. Фразата се дели на токени вака: ["I", " love", " programming"]

Сега да земеме слична фраза на македонски јазик: "Јас сакам програмирање". Тука исто така има три збора, но OpenAI Tokenizer за моделот GPT-5 ќе ја подели на 4 токени: ["Јас", " сакам", " програм", "ирање"]

Но ако земеме друг модел од OpenAI, GPT-4 (претходното семејство модели), тој ќе ја подели истата фраза дури на 7 токени: ["Јас", " са", "кам", "про", " прог", "рами", "рање"]

А од гледна точка на последните верзии од семејството модели Gemini, исто така ќе има 4 токени, но со малку поинаква поделба: ["Јас", " сакам", " програмира", "ње"]

За приближна проценка на обемот на текстот, во индустријата се користи стандарден сооднос за англискиот јазик:

• 1 токен ≈ 4 знаци
• 1 токен ≈ 0,75 збор
• 100 токени ≈ 75 збора

За македонски јазик ова правило не важи. Поради особеностите на кодирањето, еден македонски збор честопати зафаќа 2 до 3 пати повеќе токени отколку соодветниот англиски.

Зошто воопшто е потребно да се знае за токените? Пред се, поради следниве причини:

• Ограничување на контекстот (таканаречен контекстен прозорец или Context Window): секој LLM има лимит на меморија, на пример, 8.000, 32.000 или 128.000 токени. Ако вашиот разговор го надмине овој лимит, моделот ќе почне да го „заборава“ почетокот на преписката. А тоа, пак, ќе влијае врз квалитетот на одговорите на моделот.
• Цена: развивачите им плаќаат на ВИ-добавувачите (OpenAI, Anthropic) строго според бројот на испратени и примени токени.
• Брзина на работа: колку повеќе токени генерира моделот, толку подолго корисникот чека одговор.

При работата со LLM може да дојдеме до следниве заклучоци:

• Заштеда: за развивачите е поисплатливо сложените системски инструкции (промптови) да ги пишуваат на англиски јазик, тоа заштедува до 60 до 70 отсто од буџетот за API.
• Меморија: на англиски јазик невронската мрежа ќе може да задржи во меморијата (контекстниот прозорец) условно кажано огромна книга, а на македонски само половина од таа книга, бидејќи лимитот на токени ќе се исцрпи побрзо.

Компатибилност на хардверот/графичката картичка и можностите на LLM

Каков хардвер, каков компјутер е потребен за работа со LLM?

Обемот на видео меморија (VRAM) е главниот фактор што определува кои операции со моделите ви се достапни. Теоретски, не е задолжителна моќна графичка картичка, бидејќи моделот може да се стартува и на централниот процесор на компјутерот, користејќи ја оперативната меморија. Сепак, брзината при користење на моделот на процесор или на оперативна меморија многу ќе заостанува во споредба со стартувањето на графичка картичка со споредлив обем меморија. Затоа во овој случај ќе се фокусираме токму на графичката картичка како хардвер потребен за стартување на LLM.

Општо земено, колку поголем обем меморија има графичката картичка, толку поголем модел може да се стартува и толку посложени операции може да се извршуваат со него. Но пред да преминеме на разгледувањето на односот меѓу обемот на VRAM и достапните можности за работа со LLM, важно е да се разбере на што воопшто се троши меморијата:

• Параметри на моделот: секоја милијарда параметри (1B) во првобитен квалитет (FP16) зафаќа 2 GB VRAM.
• Квантизација (компресија): моделите може да се компресираат. Во квалитет INT4 (4 бита), секои 1B параметри зафаќаат само 0,5 GB VRAM.
• Контекст (KV-Cache): долгиот разговор бара многу меморија за историјата на комуникацијата.
• Обука: за дообучување (Fine-tuning) е потребна 3 до 4 пати повеќе VRAM отколку за обично стартување, бидејќи треба да се чуваат дополнителни информации (градиенти и состојби на оптимизаторот).

Сега да разгледаме кои можности на LLM се достапни при различни обеми меморија на графичката картичка.

До 8 GB VRAM заклучно (почетно ниво) Соодветно за: запознавање со технологијата, едноставни чат-ботови.

• Стартување (Inference): модели до 7B–8B параметри само во силна квантизација (INT4/Q4). Примери: Llama-3-8B (Q4), Mistral-7B (Q4).
• Должина на контекстот: ограничена (обично до 2048 токени).
• Обука: недостапна. Возможен е само LoRA-тјунинг на микро-модели (до 1B–2B параметри).

Треба да се напомене дека кога зборуваме за графички картички со обем до 8 GB, во реалноста мислиме на многу голем свет на графички картички, како за компјутери, така и за лаптопи, таблети и смартфони со различни обеми, каде што најпопуларни се 8 GB (на пример, RTX 3060 Ti, RTX 4060, RTX 4070) и 6 GB (на пример, RTX 3060 Laptop, RTX 4050). И покрај тоа што графичките картички со вакви обеми се најдоа во иста група, во реалноста разликата меѓу 6 GB и 8 GB VRAM е критична за работата со LLM. Во оваа категорија, секои 2 GB определуваат дали воопшто ќе можете локално да стартувате современ основен модел или не. Картичката од 8 GB е минималниот праг за влез во современите LLM, додека 6 GB е режим на строги компромиси и застарени или многу слаби модели.

Да направиме мала споредба на можностите на 6 GB и 8 GB VRAM според основните аспекти:

Можност / Операција 6 GB VRAM 8 GB VRAM

Стартување модели од класата 7B/8B (Llama 3, Mistral, Gemma 2) Практично невозможно без силна загуба на брзина. Моделот не се сместува во целост, дел оди во бавната RAM. Целосно стартување во квантизација Q4 (INT4). Моделот целосно се сместува во видео меморијата.

Достапна големина на контекстот Минимална (до 512–1024 токени) за микро-модели. Основна (до 2048–4000 токени) за модели од 8B. Меморијата стига за помал разговор.

Стартување микро-модели (1B–3B) (Phi-3, Gemma-2B, Qwen-2.5-3B) Целосно стартување во добар квалитет (INT8 или FP16) со долг контекст. Идеална работа, може да се стартуваат паралелно со други задачи или во максимален FP16.

Дообучување (Fine-tuning) Недостапно дури и за LoRA (само за навистина ситни модели што имаат помалку од 1B параметри). Достапен е QLoRA-тјунинг на микро-модели (1B–3B) или LoRA за едноставни задачи.

Зошто 2 GB разлика толку силно ја менуваат ситуацијата? Работата е во тоа што условен „златен стандард“ во светот на open-source невронските мрежи се моделите од 7 до 8 милијарди параметри (7B/8B). Тие имаат основен „интелект“, логика и способни се добро да комуницираат. Приближната математика на распределбата на меморијата изгледа вака:

1. Модел од 8B во компресија Q4 (4 бита) тежи приближно 4,5 до 5 GB.
2. Оперативниот систем (Windows/Linux) и отворениот прелистувач земаат уште 1,5 до 2 GB VRAM.

На крајот:

• На картичка од 8 GB: 5 GB (модел) + 1,5 GB (систем) = 6,5 GB. Остануваат уште 1,5 GB за контекст (KV-Cache). Моделот работи брзо.
• На картичка од 6 GB: 5 GB (модел) + 1,5 GB (систем) = 6,5 GB. Меморијата физички не е доволна. Системот вклучува offloading (префрлање на остатокот во обичната оперативна меморија на процесорот), поради што брзината на генерирање опаѓа 5 до 10 пати (до 1 до 3 токени во секунда).

Ако имате 6 GB VRAM, тогаш најверојатно ќе мора целосно да се откажете од моделите 7B/8B и да се фокусирате на семејствата микро-модели што сега активно се развиваат. Како на пример, Microsoft Phi-3 (3.8B), Qwen 2.5 (1.5B / 3B) или Gemma 2 (2B), кои одлично се сместуваат во 6 GB и даваат многу добар квалитет за својата големина. Сепак, не треба премногу да се потпирате на ваквите модели.

12–16 GB VRAM (основно работно ниво) Соодветно за удобен локален развој и основна автоматизација.

• Стартување (Inference): модели од 7B–8B параметри во максимален квалитет (FP16) или модели до 14B–20B параметри во компресиран вид (Q4).
• Должина на контекстот: целосни 4000 до 8000 токени за модели од 8B.
• Обука: ефикасен QLoRA-тјунинг (квантизирано дообучување) за модели од 7B–8B.

24 GB VRAM (ниво на ентузијаст / RTX 3090 / 4090) Соодветно за сериозна локална работа и создавање целосни RAG-системи.

• Стартување: модели до 30B–34B параметри во квантизација Q4. Или средни модели (14B) во квалитет FP16/INT8.
• Должина на контекстот: долг контекст (до 32k+ токени) на модели од класата 8B.
• Обука: целосен LoRA-тјунинг (без строга квантизација) за модели од 7B–8B. Брзината на обуката е значително поголема.

32 GB VRAM (среден ниво / RTX 5090) Фактички, 32 GB е „златна средина“ што овозможува да се излезе од рамките на ограничувањата на вообичаените картички од 24 GB (како RTX 3090/4090) и да се приближи до професионалното ниво.

• Стартување: модели со 30B–34B параметри во висок квалитет може да се стартуваат не во строга компресија (INT4), туку во многу попрецизен INT8 или дури FP16 (ако моделот е поблиску до 14B–20B) без ризик од преполнување на меморијата.
• Должина на контекстот: на модели од популарната класа 8B (Llama 3 / Mistral) може да се постави максимален контекст од 32k, 64k па дури и 128k токени. Меморијата ќе стигне и за самиот модел и за огромниот KV-Cache (историјата на разговорот), што е критично важно за анализа на долги документи и книги.
• Обука: со 32 GB VRAM може удобно да се дообучуваат модели со среден обем (14B–34B) на сопствени податоци преку QLoRA. Моделите од класата 7B–8B сега може да се обучуваат навистина (целосна обука или Full Fine-tuning), односно со ажурирање на сите тежини на добра големина на пакетот податоци (batch size), без страв од прекини поради недостиг на меморија.

40–48 GB VRAM (професионално ниво / две RTX 3090/4090 или една A6000) Соодветно за: комерцијален развој, работа со сложена логика.

• Стартување: тешки модели до 70B–80B параметри во компресија INT4 (на пример, Llama-3-70B Q4).
• Должина на контекстот: огромен контекст на модели од средно ниво.
• Обука: целосно дообучување (Full Fine-tuning) на модели до 7B или LoRA за модели до 34B.

80 GB+ VRAM (индустриско ниво / A100 / H100) Соодветно за enterprise-решенија и создавање сопствени модели.

• Стартување: модели од 70B+ во оригинален квалитет (FP16). Истовремено стартување на неколку модели.
• Должина на контекстот: максимален контекст (128k+ токени) за кои било достапни модели.
• Обука: целосна обука и дообучување на тешки модели (70B+) со користење на распределени пресметки.

Што да се прави ако не стига VRAM?

За жал, хардверските можности на нашите компјутерски системи честопати се ограничени, па соодветно, меморијата на графичката картичка едноставно може да не биде доволна. Што да се прави во тој случај? Постојат неколку варијанти, меѓу кои:

• CPU + RAM (таканаречен offloading): алатки како llama.cpp и LM Studio овозможуваат стартување на моделите на процесорот и на обичната оперативна меморија. Ова работи многу побавно, но овозможува бесплатно стартување на огромни модели (ако, се разбира, имате таква оперативна меморија).
• Поделба на неколку GPU: може да се обединат неколку графички картички (на пример, две картички по 12 GB за да се добијат 24 GB). Тогаш теоретски моделот автоматски ќе се подели меѓу нив.

Ок најкомплицираното помина а тоа е теоријата и се запознавме што е и како функционира LLM, а сега ајде чекор по чекор да видиме како се стартуваат погоре споменатите модели еден по еден, натенане....

 

[Fatal1ty_]

LM Studio

LM Studio претставува практична графичка апликација за локално стартување на големите јазични модели (LLM) без интернет. Програмата нуди практичен графички интерфејс за пребарување, преземање и стартување на модели (како Llama 3, Qwen, DeepSeek, Mistral и други). При тоа, готови апликации се достапни за сите распространети оперативни системи, за Windows, Linux и MacOS, и за различни архитектури, како за Intel, така и за ARM64 (за MacOS достапно е само за машини со M-чипови). Сите пресметки се одвиваат строго на локалниот хардвер, што гарантира стопроцентна приватност на податоците, а присуството на интернет по преземањето на потребните модели не е задолжително.

LM Studio е идеална за истражувачи, развивачи и за оние што сакаат целосна визуелна контрола врз секој параметар на моделот. Предности на LM Studio:

• Целосен GUI (интерфејс): готова апликација со вграден убав чат, што не бара инсталирање на дополнителни програми.
• Практично пребарување на модели: може да се пребаруваат и да се преземаат кои било модели (вклучувајќи и квантизирани .gguf модели) директно преку интерфејсот на програмата.
• Целосна контрола: рачно може да се подеси големината на контекстниот прозорец (Context Length), системскиот промпт и мноштво други поставки.
• Режим Playground: овозможува тестирање и споредба на одговорите на неколку различни модели истовремено на еден екран.
• Локален сервер: умее да подигне локален API-сервер (компатибилен со форматот на OpenAI) за поврзување на дополнителни програми.

Но не може да не се напоменат и недостатоците на LM Studio:

• Барања за ресурси: самата графичка апликација троши оперативна и видео меморија на компјутерот.
• Помалку практична за работа во позадина: програмата треба да се држи отворена. Таа не е развиена како системска служба што тивко се стартува заедно со оперативниот систем.

Инсталирање на LM Studio

Официјалните верзии се достапни на официјалниот сајт на LM Studio, на страницата Download LM Studio - Mac, Linux, Windows. Или на главната страница, LM Studio Bionic - Your Agent for Work and Code. При отворањето на главната страница, на корисникот веднаш му се нуди да го преземе потребниот инсталациски фајл за тековниот оперативен систем. Да го разгледаме инсталирањето на Windows и на Linux (Ubuntu).

Инсталирање на Windows

Одиме на адресата Download LM Studio - Mac, Linux, Windows, ја избираме ОС Windows и потребниот тип на систем, x86 или ARM64, и кликнуваме на копчето „Download for Windows“.



По кликнувањето се презема инсталерот во форма на exe-фајл. Стартувајте го фајлот и следете ги стандардните чекори на волшебникот за инсталирање.

По завршувањето на инсталирањето, да ја стартуваме програмата. Драјверите NVIDIA CUDA за забрзување преку GPU обично се повлекуваат автоматски, ако се ажурирани во системот.

Инсталирање на Linux (Ubuntu)

За инсталирање на програмата на Linux (на пример на Ubuntu), исто така може да отидеме на адресата Download LM Studio - Mac, Linux, Windows и да ја избереме ОС Linux и потребниот тип на систем, x86 или ARM64. За преземање се нудат две варијанти: апликација во формат AppImage и во форма на пакет deb. Во принцип нема разлика кој начин ќе го изберете. Сепак, во случајот со Ubuntu/Debian, според мене, подобро е да се преземе и да се инсталира пакетот .deb, бидејќи помалку зафаќа.



Да ги разгледаме двата начина.

deb-пакет

Кликаме на копчето „Download for .deb for Linux“ за да го преземеме пакетот. По преземањето, во терминалот одиме до папката со преземања и го инсталираме deb-пакетот со командата:

sudo apt install ./LM-Studio-0.4.16-2-x64.deb

По ова, на панелот со апликации (Show Apps) ќе се додаде икона на апликацијата и ќе можеме да ја стартуваме со клик на глувчето.

AppImage

Кликаме на копчето „Download for AppImage for Linux“ за да ја преземеме апликацијата во формат AppImage. По преземањето, одиме во папката со преземања и потоа го правиме фајлот извршлив со помош на командата:

chmod +x LM-Studio-0.4.16-2-x64.AppImage

За стартување на фајлови во формат AppImage е потребно да се инсталира FUSE:

# за Ubuntu / Debian (последните верзии како 22.04, 24.04, 26.04)

sudo apt install libfuse2t64

# за Fedora / RHEL

sudo dnf install fuse-libs

По ова, доволно е апликацијата да се стартува со командата:

./LM-Studio-0.4.16-2-x64.AppImage

Ако користите современи дистрибуции на Ubuntu (на пример, Ubuntu 24.04+), при стартувањето може да се појави грешка поради новите ограничувања за користење на AppArmor и непривилегираните кориснички именски простори (namespaces). Основниот проблем се состои во конфликтот меѓу безбедносниот систем на Chromium и механизмите за монтирање на AppImage во Linux. Прелистувачкото јадро Electron, врз кое е изградена LM Studio, бара посебни root-права (mode 4755) за компонентата chrome-sandbox. Најлесниот начин да се стартува апликацијата во тој случај е присилно да се исклучи Chromium на Chrome со помош на посебниот флаг --no-sandbox:

./LM-Studio-0.4.16-2-x64.AppImage --no-sandbox

Важно за Ubuntu: за хардверско забрзување мора да ги имате инсталирано драјверите за NVIDIA. Нивната активност може да ја проверите со командата nvidia-smi во терминалот.

Пребарување и преземање на првиот модел

Сега треба да инсталираме LLM модел со кој сакаме да комуницираме. LM Studio поддржува многу различни модели. Каталогот на модели и описите за нив може да се погледнат на страницата Model Catalog - LM Studio

И така, да ја стартуваме LM Studio. Ќе ни се прикаже некаков вид на welcome прозорец. Кликаме на копчето „Get Started“. Во следниот прозорец програмата веќе ни нуди да инсталираме еден од моделите:

• Turn on Developer Mode (Вклучи режим за развивачи) Оваа поставка го стартува локалниот сервер на LM Studio веднаш при стартот на програмата. Серверот го имитира API на OpenAI (на портот http://localhost:1234). Ова е главната алатка за поврзување на LM Studio со надворешен софтвер. Ако сакате да го поврзете вашиот модел (на пример, истиот Gemma 4 E4B) со дополнителни плагини за прелистувачот, со екстензии во VS Code (за пишување код), со агенти или со RAG-системи, ним ќе им биде потребен овој API. Самиот сервер троши занемарливо малку ресурси. Во принцип, за обичен чат оваа функција не е задолжителна. Сепак, дури и ако сега само ќе разговарате во чатот, во иднина оваа функција ќе ве ослободи од потребата секој пат рачно да го барате и да го стартувате серверот во интерфејсот.
• Add lms (LM Studio CLI) to your Path (Додади lms во PATH) Оваа поставка овозможува да управувате со LM Studio преку терминал (командна линија) од која било папка на компјутерот. Благодарение на оваа можност, ќе можете да преземате, да стартувате и да запирате модели со едноставни текстуални команди. Ова е незаменливо за автоматизација, за пишување скрипти или ако во принцип претпочитате да работите преку конзола. Ова е апсолутно безбедно. Програмата едноставно го запишува патот до својот извршен фајл во системските променливи на вашиот оперативен систем. Тоа никако не влијае врз брзината на работа на компјутерот. Затоа, ако планирате да комуницирате со програмата преку конзола, на пример, за автоматизација, може да ја вклучите. Ако планирате да го користите исклучиво убавиот графички интерфејс на LM Studio и да кликате со глувчето, ова поле може спокојно да го отчекирате.

Најлесно е да ги вклучите двете поставки, тоа е стандарден комплет за удобна работа без ограничувања во иднина: тие многу ќе ви го олеснат животот ако планирате да ја користите LM Studio не само како обичен чат, туку и за интеграција со други програми. Сепак, не е задолжително да ги вклучите двете поставки, по потреба може да ги приклучите подоцна во поставките на програмата.

За да преминеме директно кон работата со моделите, кликаме на копчето „Continue to LM Studio“. По ова ќе ни се отвори главниот прозорец на програмата, каде што главниот дел ќе го зафаќа полето за чат.

За да пребаруваме модели за инсталирање, кликнеме на иконата на лупата (Search) на левиот панел. По ова ќе ни се отвори прозорецот за пребарување. Ќе бараме доста популярен модел, наменет за генерирање текст, DeepSeek-R1-0528-Qwen3-8B. Да го внесеме во полето за пребарување:



Првата верзија во листата на пребарување ќе биде токму онаа што ни треба. Треба да се напомене дека различни компании, па дури и одделни лица, може да објавуваат своја верзија на моделот, па затоа при внесувањето на името на моделот може да видиме и по неколку варијанти за едно исто име.

Во прозорецот за пребарување треба да се напомене и уште еден момент: изборот на квантизација. Во десниот дел на избраниот модел, во секцијата Download Options, ќе се појави листа на фајлови со различни нивоа на компресија (квантизација). Квантизацијата овозможува да се намали големината на моделот за да зафаќа помалку меморија и да работи побрзо на обичен компјутер. Колку е поголемо нивото на квантизација, толку помалку меморија зафаќа моделот, но заедно со тоа се намалува и квалитетот на неговите одговори. Така, во случајот со нашиот модел се нудат четири варијанти на квантизација:

• Q3_K_L: најмали барања за ресурсите на компјутерот (потребна е помалку меморија, помала големина), но и најнизок квалитет
• Q4_K_M: квалитетот е подобар, но и бара повеќе ресурси. Општо земено, ова е оптималната рамнотежа меѓу квалитетот и брзината
• Q6_K: квалитетот е уште подобар, но и барањата кон компјутерот се повисоки
• Q8_K: максимален квалитет и највисоки барања кон компјутерот

Треба да се земе предвид големината на моделот и присуството на слободно место на дискот. Оптималната варијанта на односот квалитет/брзина на работа/потрошени ресурси е Q4_K_M или Q5_K_M. По правило, стандардно се нуди варијантата Q4_K_M. Да ја оставиме стандардната варијанта и за преземање на моделот да кликнеме на копчето „Download“.



Користење на моделот во режим на чат

По завршувањето на преземањето ќе ни се прикаже соодветна порака.

Кликаме на копчето „Load Model“ за да го вчитаме моделот во програмата во режим на чат. По ова, во прозорецот за чат може да се комуницира со моделот.

Поставки

По потреба, секогаш може да ги промениме стандардните поставки. За таа цел кликаме на иконата на запченикот во долниот лев агол на програмата и ќе ни се отвори прозорецот со поставки.
Нема да ги опишувам сите можни поставки, бидејќи ги има доста. Ќе се задржам само на една, Models Directory. Таа ја покажува папката каде што стандардно се преземаат LLM моделите. Стандардно, тоа обично е директориумот .lmstudio/models во папката на тековниот корисник. По потреба може да ја промениме оваа папка во некоја која вам ви одговара.

 

[Fatal1ty_]

Ollama

Ollama нуди уште еден начин за стартување и за интеракција со големите јазични модели LLM. Во поглед на користењето, оваа алатка е нешто посложена од LM Studio. Ако LM Studio претставува целосна графичка програма што лесно и интуитивно можат да ја користат дури и оние што се воопшто далеку од сферата на ИТ, Ollama работи во заднина како невидлив мотор (сервис). А за управување со моделите во Ollama, стандардно се користат команди во конзолата/терминалот.

Ollama е идеална за автоматизација, за интеграција во други апликации и за работа во стилот „подеси и заборави“.

Предности на Ollama:

• Минимализам и леснотија: работи како сервис во заднина, не троши ресурси на компјутерот за исцртување на сложен интерфејс.
• Практичен CLI: управувањето со моделите се одвива преку едноставни текстуални команди во терминалот.
• Автоматско управување со меморијата: Ollama сама одлучува како најдобро да ги распредели слоевите на моделот меѓу графичката картичка (VRAM) и процесорот (RAM).
• Создавање прилагодени модели: преку посебен конфигурациски фајл (Modelfile) во неколку линии може да му се зададе на моделот системски промпт (на пример, „Ти си експерт за Python“) или да се смени температурата на одговорите.
• Идеална за екосистема: има вграден API, благодарение на кој Ollama е поддржана „in the box“ од стотици плагини (за VS Code, Obsidian, Telegram-ботови и слично).

Недостатоци на Ollama:

• Нема свој интерфејс: по инсталација е достапен само чат во црниот прозорец на терминалот. За убав UI треба одделно да се инсталира дополнителен софтвер (на пример, Open WebUI).
• Скриени поставки: сложено е да се сменат параметрите на генерирањето (на пример, контекстниот прозорец или температурата) директно за време на разговорот.
• Ограничен каталог: моделите се преземаат само од официјалното складиште на Ollama. Не може едноставно да се влезе на Hugging Face (како во случајот со LM Studio), да се преземе случаен фајл во формат .gguf и да се стартува без претходно подесување.

Инсталирање на Ollama

Инсталирањето одзема само неколку минути. Целосните упатства и дистрибуции секогаш се достапни на официјалниот сајт Ollama. Понатаму ќе ги разгледаме официјалните начини на инсталирање, но веднаш ќе укажам на алтернативен извор: ако поради едни или други причини не успевате да ги преземете потребните фајлови за инсталирање (на пример, поради блокирање на адресите), сите нив може да ги најдете на официјалното складиште на Ollama на GitHub:




Тука може да се најдат фактички истите пакети што се нудат за преземање од официјалниот сајт.

Windows

За преземање на програмата за инсталирање, да отидеме на официјалниот сајт, на страницата Ollama за Windows, и да кликнеме на копчето „Download for Windows“:



По преземањето, ја стартуваме програмата за инсталирање и поминеме низ чекорите за инсталирање. По инсталирањето, програмата ќе работи во позадина (во системската лента).

Како алтернатива, за инсталирање може да се користи PowerShell. За инсталирање преку PowerShell се применува следнава команда:

irm https://ollama.com/install.ps1 | iex

Ако претходните начини поради едни или други причини не се достапни, инсталерот може да се преземе од складиштето на GitHub. Инсталерот претставува фајл „OllamaSetup.exe“, кој е ист како инсталерот што се нуди на сајтот на Ollama.

MacOS

За инсталирање на MacOS може да се изврши следнава команда во терминалот:

curl -fsSL https://ollama.com/install.sh | sh

Или да се преземе програмата за инсталирање од адресата Download Ollama on macOS.

Ако претходните начини поради едни или други причини не се достапни, инсталерот може да се преземе од складиштето на GitHub. Сликата за инсталирање претставува фајл „OllamaSetup.dmg“, кој е ист како инсталерот што се нуди на сајтот на Ollama.

Linux

За инсталирање на Linux потребно е да се изврши една команда во терминалот:

curl -fsSL https://ollama.com/install.sh | sh

Ако претходните начини поради едни или други причини не работат, тогаш програмата може да се инсталира рачно. Во тој случај, вистина, ќе бидат потребни многу повеќе чекори. За таа цел, од складиштето на GitHub може да се преземе еден од двата фајла:

• ollama-linux-amd64.tar.zst: за Intel x86-64
• ollama-linux-arm64.tar.zst: за Aarch64 (ARM64)

Во тој случај, по преземањето на фајлот, прво да создадеме папка во која ќе ја отпакуваме програмата. Да претпоставиме дека тоа ќе биде папката „/usr/local/ollama“:

sudo mkdir /usr/local/ollama

Потоа во конзолата да отидеме до папката во која е преземен фајлот (на пример, ollama-linux-amd64.tar.zst) и да ја извршиме командата за отпакување:

sudo tar -I zstd -xf ollama-linux-amd64.tar.zst -C /usr/local/ollama

На тој начин, основниот фајл на програмата ќе се најде во директориумот „/usr/local/ollama/bin“. За да ја провериме успешноста на инсталирањето, отидиме во оваа папка во конзолата и да ја провериме верзијата на програмата со помош на командата ollama -v:

roka@Roka:/usr/local/ollama/bin$ ./ollama -v

Warning: could not connect to a running Ollama instance

Warning: client version is 0.30.10

roka@Roka:/usr/local/ollama/bin$

Како што се гледа од конзолата, во мојот случај верзијата на програмата е 0.30.10. Освен тоа, исписот ни соопштува дека не е можно да се поврземе со сервисот Ollama. Што е природно, бидејќи тој не е стартуван.

Како што веќе беше кажано, Ollama функционира како сервис, работејќи во заднина. Благодарение на тоа, преку Ollama може да се комуницира со LLM. И за да ја провериме исправноста, движокот може да се стартува рачно со помош на командата ollama serve:

roka@Roka:/usr/local/ollama/bin$ ./ollama serve

Couldn't find '/home/roka/.ollama/id_ed23456'. Generating new private key.

Your new public key is:



.......................................................................................

time=2026-06-19T18:29:02.319+03:00 level=INFO source=types.go:32 msg="inference compute" id=0 filter_id=0 library=CUDA compute=8.6 name=CUDA0 description="NVIDIA GeForce RTX 3090 Ti" libdirs=ollama,cuda_v13 driver=13.2 pci_id=0000:01:00.0 type=discrete total="23.5 GiB" available="23.3 GiB"

time=2026-06-19T18:29:02.319+03:00 level=INFO source=routes.go:2031 msg="vram-based default context" total_vram="23.5 GiB" default_num_ctx=32768

Поставување на автоматско стартување

Ако сe работи и сакате Ollama автоматски да се стартува при подигањето на системот, може да го затворите терминалот (Ctrl+C) и да поставите автоматско стартување преку systemd, за да работи Ollama во заднина. За таа цел, треба да извршиме низа дејства.

Да создадеме изолиран корисник и група заради безбедност:

sudo useradd -r -s /bin/false -U -m -d /usr/share/ollama ollama

sudo usermod -a -G ollama $(whoami)

Да создадеме фајл со конфигурација на службата:

 sudo nano /etc/systemd/system/ollama.service

Да го вметнеме во овој фајл следниов текст на конфигурацијата:

[Unit]

Description=Ollama Service

After=network-online.target

[Service]

ExecStart=/usr/local/ollama/bin/ollama serve

User=ollama

Group=ollama

Restart=always

RestartSec=3

Environment="PATH=$PATH"

[Install]

WantedBy=multi-user.target

Го зачувуваме фајлот. Ако работиме во nano, тогаш треба да притиснеме по редослед: Ctrl + O, потоа Enter, и да го затвориме уредувачот преку Ctrl + X.

И на крајот, да ја стартуваме службата и да ја додадеме во автоматското стартување:

sudo systemctl daemon-reload

sudo systemctl enable ollama

sudo systemctl start ollama

Ако веќе не ни треба Ollama и сакаме да се отстрани, тогаш за таа цел прво мора да се отстрани сервисот ollama:

sudo systemctl stop ollama

sudo systemctl disable ollama

sudo rm /etc/systemd/system/ollama.service

И исто така да се отстранат корисникот и групата на сервисот Ollama:

sudo userdel ollama

sudo groupdel ollama

sudo rm -r /usr/share/ollama

Поставување на патеките до моделите

Пред да преминеме кон користењето на LLM моделите, треба да кажеме неколку зборови за тоа каде ќе се складираат тие модели. Затоа што моделите може да зафаќаат многу гигабајти, па соодветно може да се појави потреба од повнимателно управување со простор на дискот и потреба од поставување на местото за складирање на моделите.

Во кој било систем (Windows, Linux, MacOS), директориумот за складирање на моделите може да се зададе со помош на променливата на околината OLLAMA_MODELS, по што е потребно да се рестартира Ollama за таа да ги прифати поставките.

Во Linux треба да се земе предвид дека корисникот во чие име се стартува Ollama мора да има пристап до папката со моделите. На пример, ако претходно ја создадовме и ја стартувавме службата во име на корисникот ollama и групата ollama, тогаш соодветно треба да додадеме пристап до папката со модели за тој корисник и таа група:

sudo mkdir -p /path/to/your/custom/models

sudo chown -R ollama:ollama /path/to/your/custom/models

За разлика од работата на самиот модел како сервис (каде што е зададен корисникот ollama), при рачно стартување на Linux процесот работи во име на вашиот личен корисник. Проверете дали вашиот корисник има права за читање и запишување во новата папка со модели. Ако сте ја создале оваа папка претходно преку sudo, вратете и ги правата на вашиот корисник:

sudo chown -R $USER:$USER /path/to/your/custom/models

Ако променливата на околината OLLAMA_MODELS не е зададена, Ollama користи цврсто впишани стандардни патеки за секој оперативен систем.

Во Linux патеката зависи од тоа како е стартувана Ollama:

• Ако Ollama работи како служба на systemd (стандардно инсталирање): /usr/share/ollama/.ollama/models (Оваа папка му припаѓа на системскиот корисник ollama).
• Ако ја стартувате Ollama рачно (преку командата ollama serve): ~/.ollama/models (или /home/именакорисникот/.ollama/models)

На Windows сите модели се преземаат во home профилот на тековниот корисник:

• C:\Users\<Именакорисникот>\.ollama\models
• Кратката патеко до моделот: %USERPROFILE%\.ollama\models

На Mac папката е скриена во библиотеките на корисникот: ~/.ollama/models (или /Users/вашето_име/.ollama/models)

Треба да се напомене дека внатре во папката „models“ нема да ги видите вообичаените фајлови со наставка „.gguf“ и со имиња на невронските мрежи. Ollama ги дели моделите на манифести и скриени блокови со податоци (блобови):

• Во папката manifests се наоѓаат мали текстуални конфигурации (метаподатоци на моделите).
• Во папката blobs се наоѓаат самите тежини на моделите, преименувани во долги хеш-низи (на пример, sha256:a476a...). Не смее рачно да се преместуваат или да се преименуваат одделни фајлови внатре во овие папки, тоа ќе ја расипе базата на податоци на Ollama.

Ако сакате да ги зачувате веќе преземените невронски мрежи, едноставно преместете ја содржината на старата папка models во вашиот нов директориум пред да ја рестартирате апликацијата.

Стартување на моделите преку терминал

Управувањето со Ollama се одвива преку командната линија (cmd, PowerShell или терминалот на Linux/macOS). Целата библиотека на модели е достапна на страницата Модели на Ollama:



За пример да го земеме моделот deepseek-r1 (поточно, тоа е семејство модели) и го внесеме името на моделот во полето за пребарување:



Во листата на резултати да ја избереме ставката deepseek-r1 и кликаме на неа за да ги погледнеме информациите за моделот:



Тука може да видиме различни информации за моделот, меѓу кои и параметрите за неговото стартување, поддржаните апликации, податоците за лиценцата, верзиите на моделот што се разликуваат по тежини и по квантизација и слично.

Поконкретно, за стартување на моделот deepseek-r1 во конзолата се применува командата:

ollama run deepseek-r1

Општо земено, за стартување на модел во Ollama се применува командата:

ollama run <име_на_моделот>

Ако моделот го нема на компјутерот, тој ќе се преземе автоматски.

На пример, да го стартуваме (а заодно и да го преземеме, ако го нема) моделот deepseek-r1 со командата ollama run deepseek-r1:

roka@Roka:/usr/local/ollama/bin$ ./ollama run deepseek-r1

pulling manifest

pulling e6a7edc1a4d7: 100% ▕█████████████████████████████████████████████████████████████████████████████████████████▏ 5.2 GB

pulling c5ad996bda6e: 100% ▕█████████████████████████████████████████████████████████████████████████████████████████▏ 556 B

pulling 6e4c38e1172f: 100% ▕█████████████████████████████████████████████████████████████████████████████████████████▏ 1.1 KB

pulling ed8474dc73db: 100% ▕█████████████████████████████████████████████████████████████████████████████████████████▏ 179 B

pulling f64cd5418e4b: 100% ▕█████████████████████████████████████████████████████████████████████████████████████████▏ 487 B

verifying sha256 digest

writing manifest

success

>>> Send a message (/? for help)

По преземањето, ќе можеме да го користиме моделот и да внесеме порака.

За излез од разговорот, внесете ја во чатот командата /bye.

Ако во иднина се појави потреба да се отстрани модел, тогаш за таа цел се применува командата:

ollama rm <име_на_моделот>

За преглед на листата на преземени модели се применува командата ollama list:

 roka@Roka:/usr/local/ollama/bin$ ./ollama list

NAME ID SIZE MODIFIED

deepseek-r1:latest 5371862aee7d 5.2 GB About an hour ago

roka@Roka:/usr/local/ollama/bin$

Логови и оценка на ефикасноста

При работата со Ollama може да се појави потреба да се оцени брзината на обработка на барањето. Така, по секое барање до моделот, Ollama логира помошни информации што овозможуваат да се дознае како е обработено барањето. Ако Ollama ја стартуваме рачно преку командата ollama serve, тогаш информациите се логираат директно на конзолата. Ако Ollama се стартува автоматски како сервис, тогаш информациите се логираат во стандардните системски дневници или во посебни текстуални фајлови:

• Linux (systemd). Ако Ollama е инсталирана преку официјалната скрипта, таа работи како системска служба на systemd. Логовите се запишуваат во бинарниот дневник journalctl.

# Команда за преглед на последните логови во реално време:

journalctl -u ollama -f



# Команда за преглед на последните 100 линии (без блокирање на терминалот):

journalctl -u ollama -n 100 --no-pager

• Windows. При автоматско стартување на Windows, Ollama ги запишува логовите во скриената корисничка папка AppData. Патека до фајлот со логови: C:\Users\<Именакорисникот>\AppData\Local\Ollama\server.log
• macOS. На Mac, Ollama се регистрира како агент за стартување (LaunchAgent) и го пренасочува стандардниот излез во одделни фајлови со логови. Патека до основниот лог на серверот:

~/.ollama/logs/server.log

Патека до логовите на службата (LaunchAgent):

~/Library/Logs/Ollama/ (таму може да се наоѓаат фајловите stdout.log и stderr.log).

За брз преглед преку терминалот може да се користи командата:

tail -f ~/.ollama/logs/server.log

По секое барање до LLM, Ollama логира служебни информации за обработката. Поконкретно, во логовите може да видиме линии слични на следниве:

slot print_timing: id 0 | task 1515 | prompt eval time = 392.86 ms / 973 tokens ( 0.40 ms per token, 2476.72 tokens per second)

slot print_timing: id 0 | task 1515 | eval time = 73891.04 ms / 8975 tokens ( 8.23 ms per token, 121.46 tokens per second)

slot print_timing: id 0 | task 1515 | total time = 74283.89 ms / 9948 tokens

slot print_timing: id 0 | task 1515 | graphs reused = 10445

slot release: id 0 | task 1515 | stop processing: n_tokens = 9962, truncated = 0

Намерно ги издвоив овие линии, бидејќи тие детално опишуваат две сосема различни фази на работата на невронската мрежа. Во секој конкретен случај бројките ќе се разликуваат. Но да видиме што значат тие конкретно во овој случај.

• Фаза Prompt Eval (обработка на барањето)

prompt eval time = 392.86 ms / 973 tokens (2476.72 tokens per second)

Тука го гледаме времето што графичката картичка го потрошила за да го „прочита“, „разбере“ и да го вчита во својата меморија (KV-cache) контекстот или историјата на преписката со обем од 973 токени. Резултат: брзината од 2476 токени во секунда е добар показател за графичка картичка од потрошувачко ниво. На CPU таквата брзина на обработка на промптот принципиелно е невозможна (таму таа ретко надминува 50 до 100 токени во секунда). Графичката картичка моментално „проголта“ речиси илјада токени за помалку од половина секунда.

• Фаза Eval (генерирање на одговорот)

eval time = 73891.04 ms / 8975 tokens (121.46 tokens per second)

Оваа линија го одразува непосредното создавање на текстот на одговорот (генерирање токен по токен). Моделот даде огромен одговор со должина од 8975 токени (во мојот случај треба да се укаже дека за DeepSeek-R1 тоа е норма, бидејќи таа многу „размислува“ внатре во таговите <think>, имитирајќи обмислување на барањето). За тоа отидоа 73,8 секунди. Резултат: брзина од 121,46 токени во секунда. Во зависност од моделот и графичката картичка, овие резултати може да се оценуваат различно, но, на пример, во мојот случај станува збор за моделот DeepSeek-R1 8B и графичката картичка RTX 3090, што претставува максимална брзина за RTX 3090 Ti. Но ако пресметките се одвиваа на CPU, брзината ќе паднеше приближно на 5 до 12 токени во секунда.

• Резултат на сесијата:

total time = 74283.89 ms / 9948 tokens

stop processing: n_tokens = 9962, truncated = 0

Вкупно, за целата задача (читање + генерирање текст од речиси 10 илјади токени) отидоа 74,2 секунди. Параметарот truncated = 0 означува дека контекстот не бил отсечен, моделот се сместил во лимитите на меморијата и целосно ја завршил својата мисла.

 

[Fatal1ty_]

llama.cpp

llama.cpp претставува лесен начин за стартување на големите јазични модели LLM на обичен потрошувачки хардвер. Главната цел на проектот е да обезбеди максимална продуктивност на вештачката интелигенција без голема зависност (како Python или PyTorch) и да овозможи ефикасно искористување како на централниот процесор (CPU), така и на графичките картички (GPU). Во исто време, овој начин на стартување на LLM моделите повеќе им одговара на понапредните корисници отколку на оние кои користат LM Studio или Ollama.

Главни предности на llama.cpp

• Минимална потрошувачка на ресурси: најлесниот engine што постои. Не му се потребни гигабајти библиотеки.
• Работа на CPU: одлично ги стартува моделите дури и на обични процесори благодарение на длабоката оптимизација (AVX2, AVX-512, ARM Neon).
• Мултиплатформност: работи насекаде, од суперкомпјутери и гејмерски компјутери до смартфони со Android/iOS и едноплочни платформи како Raspberry Pi.
• Целосна контрола: дава пристап до стотици фини поставки на интерфејсот преку аргументи на командната линија.
• Основа на индустријата: проектите Ollama, LM Studio и стотици други програми внатрешно го користат токму моторот llama.cpp, односно претставуваат надградба врз llama.cpp.

Општи недостатоци на llama.cpp:

• Праг за влез: отсуството на стандарден убав интерфејс „од кутија“ ги плаши обичните корисници.
• Управување со моделите: нема вградена команда за автоматско ажурирање или преземање на моделите (треба да се оди во прелистувачот на Hugging Face и таму да се бара потребниот модел и да се проучуваат неговите параметри).
• Рутина со патеки: постојано треба да се впишуваат долги патеки до фајловите во терминалот или да се создаваат .bat / .sh скрипти за автоматизација на стартувањето.

Всушност, Ollama и LM Studio се графички или сервисни надградби врз моторот на llama.cpp. Тие се создадени за да не мора корисникот да работи (или да работи помалку) со конзолата. Споредба со LM Studio

• Предност на llama.cpp: LM Studio е изградена врз основа на Electron (веб-технологии за десктоп апликации). Поради тоа, самата обвивка на LM Studio троши многу оперативна меморија на компјутерот уште пред стартувањето на вештачката интелигенција. llama.cpp троши ресурси само за самиот модел.
• Недостаток на llama.cpp: во LM Studio има убав чат, практично пребарување низ Hugging Face и автоматска детекција на вашата графичка картичка. Во llama.cpp ќе мора рачно да барате, да преземате фајлови и да ја подесувате видео меморијата.

Споредба со Ollama

• Предност на llama.cpp: Ollama ги крие фајловите на моделите од корисникот во своите внатрешни папки и ги преименува. Не може едноставно да земете произволен .gguf фајл од својот диск и да го стартувате со една команда, тој ќе треба да се импортира преку конфигурацискиот фајл Modelfile. llama.cpp стартува кој било локален фајл моментално.
• Недостаток на llama.cpp: Ollama работи како служба во заднина. Таа умее автоматски да го исфрли моделот од видео меморијата ако не го користите, и да го вчита назад при ново барање. llama.cpp го држи моделот во меморијата постојано, се додека рачно не ја затворите конзолата.

Инсталирање на llama.cpp

Во моментов, развивачите на llama.cpp нудат низа готови бинарни фајлови за различни оперативни системи и архитектури, кои се достапни за преземање на страницата со изданија на складиштето на llama.cpp на GitHub, Releases · ggml-org/llama.cpp



Варијанта за Windows

Најбрзиот начин за Windows е користењето на готовите бинарни фајлови. За таа цел, да ја отвориме претходно споменатата страница со изданија на складиштето на llama.cpp на GitHub и да го преземеме архивот за нашата архитектура. Обрнете внимание на типот на вашата графика:

• За стартување на моделот на процесорот (без графичка картичка) се презема архивот со подниза (CPU)
• За графички картички NVIDIA (со поддршка за CUDA) се презема фајлот со подниза (CUDA 12) или (CUDA 13). Верзијата на CUDA (12 или 13) мора да одговара на драјверите што ги имате инсталирано.

По преземањето, ја распакуваме архивата во погодна папка (на пример, C:\llama-cpp\).

MacOS

За MacOS исто така најлесно е да се преземе архивот со готови бинарни фајлови и по преземањето да се отпакува архивата во погодна папка. Во моментов се достапни варијанти за двете архитектури: Intel (x86) и Apple Silicon (arm64).

Linux (Ubuntu / Debian)

Кај Linux малку се копликуваат работите отколку кај Windows и MacOS. Во моментов (23 Август 2026) развивачите нудат низа готови верзии за Ubuntu, од кои секоја е составена за конкретна архитектура на процесорот и за одреден тип на графички забрзувач (графичка картичка или вградена графика). Поконкретно, варијанти за процесори (без користење на графичка картичка):

• Ubuntu x64 (CPU): за стандардни десктоп компјутери, сервери и лаптопи базирани на обични процесори Intel или AMD (64-битни). Највисока компатибилност. Ќе се стартува на речиси кој било современ компјутер. Без користење на графичка картичка.
• Ubuntu arm64 (CPU): за уреди базирани на ARM-архитектура. Тука спаѓаат плочите Raspberry Pi 4 / 5, Orange Pi, серверите на ARM (на пример, AWS Graviton) или лаптопите со ARM-процесори управувани од Linux. Без користење на графичка картичка.

Овие верзии ги извршуваат сите пресметки на процесорот (CPU) и ја користат оперативната меморија на компјутерот (RAM).

Варијанти за графички картички (забрзување преку GPU)

• Ubuntu x64 (Vulkan): универзална мултиплатформска варијанта за кои било графички картички што го поддржуваат API Vulkan. Идеално одговара ако имате вградена графика Intel/AMD, или дискретна картичка за која нема специјализирани верзии. Исто така честопати се користи за стари графички картички NVIDIA/AMD.
• Ubuntu arm64 (Vulkan): за ARM-уреди (на пример, напредни мини компјутери или таблети на Linux) што имаат графичко јадро со поддршка за Vulkan.
• Ubuntu x64 (ROCm 7.2): специјализирана верзија за современи графички картички AMD Radeon (архитектурите RDNA2/RDNA3, како RX сериите 6000 и 7000). ROCm е директен аналог на технологијата CUDA од NVIDIA, но за AMD. Дава максимална брзина на работа на картичките Radeon.
• Ubuntu x64 (OpenVINO): за процесори и вградена графика од Intel (на пример, процесорите Intel Core со вградена графика Iris Xe/Intel Arc, или новите чипови Core Ultra со NPU). Производот OpenVINO е развиен од Intel специјално за забрзување на невронските мрежи на нивниот сопствен хардвер.
• Ubuntu x64 (SYCL FP32) и Ubuntu x64 (SYCL FP16): специјализирани верзии за современи графички картички Intel Arc и за податочни центри базирани на графика од Intel (преку технологијата oneAPI / SYCL).

Овие верзии ја искористуваат видео меморијата (VRAM) и графичкиот чип, што дава огромно зголемување на брзината на генерирање текст.

На тој начин, може да се избере потребната варијанта на архивот, да се преземе и да се отпакува на потребното место на дискот.

Обрнете внимание дека, за разлика од варијантите за Windows, тука отсуствува верзија за NVIDIA (CUDA). Библиотеките на NVIDIA CUDA цврсто се врзуваат за верзијата на драјверот во системот. CUDA-фајл компајлиран на туѓ сервер може едноставно да одбие да се стартува на вашиот Ubuntu поради најмало несовпаѓање на верзиите. За картичките NVIDIA на Linux, најдобро решение останува брзата изградба од изворниот код, или стартувањето преку Docker-контејнер, каде што сите зависности се веќе изолирани.

Во краен случај, ако категорично не сакате ништо да компајлирате, може да ја користите универзалната варијанта Ubuntu x64 (Vulkan). API Vulkan е поддржан од драјверите на NVIDIA во Linux. Оваа варијанта ја искористува графичката картичка NVIDIA. Сепак, брзината на генерирање (токени во секунда) ќе биде пониска отколку при користење на стандадниот CUDA-engine, бидејќи Vulkan е помалку ефикасно оптимизиран за архитектурата на графичките картички од NVIDIA.

Затоа, ако вашата графичка картичка хардверски ја поддржува технологијата CUDA, која обезбедува максимална брзина на работа на LLM, тогаш идеална варијанта претставува изградбата од изворниот код. Изградбата ќе одземе неколку минути и ќе создаде извршен фајл идеално оптимизиран токму за вашите CUDA-драјвери. Да ја разгледаме подетално оваа варијанта.

Пред компајлирањето, пред се, проверете дали во системот се инсталирани драјверите за NVIDIA и CUDA Toolkit. За проверка може да се користи командата nvcc --version, која треба да ја испише верзијата на CUDA, нешто како следново:

roka@Roka:~$ nvcc --version

nvcc: NVIDIA (R) Cuda compiler driver

Copyright (c) 2005-2026 NVIDIA Corporation

Built on Fri_Apr_24_07:22:02_PM_PDT_2026

Cuda compilation tools, release 13.3, V13.3.33

Build cuda_13.3.r13.3/compiler.37862127_0

roka@Roka:~$

Следно е да ги инсталираме потребните алатки:

sudo apt update

sudo apt install build-essential cmake git -y

Потоа да го клонираме складиштето llama.cpp и одете во папката на проектот:

git clone https://github.com/ggml-org/llama.cpp

cd llama.cpp

Понатаму, да го изградиме проектот:

• Само за CPU

cmake -B build

cmake --build build --config Release

• За графички картички NVIDIA (со CUDA)

cmake -B build -DGGML_CUDA=ON

cmake --build build --config Release

Компајлираните извршни фајлови ќе се појават во фолдерот build/bin/.

Преземање на моделите (GGUF)

За работа со llama.cpp потребно е да се преземат компајлираните фајлови на проектот (или да се изградат од изворниот код), да се преземе модел во формат GGUF и да се стартува преку командната линија.

llama.cpp работи исклучиво со модели во формат .gguf. За нивно пребарување може да се отиде на сајтот Hugging Face, кој нуди најголемото складиште на различни LLM модели.

Обично таквите модели во името имаат суфикс -GGUF (на пример, „Qwen2.5-7B-Instruct-GGUF“ или „Llama-3-8B-Instruct-GGUF“).

На пример, да го земеме моделот DeepSeek-R1-0528-Qwen3-8B-GGUF, кој е достапен на адресата unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF · Hugging Face. За преземање на фајловите на моделот, кликаме на табот Files and versions:



Тука може да се видат различни верзии на моделот со различни нивоа на квантизација. Да го преземеме фајлот на моделот со потребното ниво на квантизација. Оптимален избор по односот брзина/квалитет е квантизацијата Q4_K_M или Q5_K_M. На пример, да ја земеме верзијата DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf, која тежи малку повеќе од 5 GB.

Стартување на LLM моделите

Во современите верзии на llama.cpp, основните алатки се нарекуваат llama-cli (интерфејс на командната линија) и llama-server (локален сервер со веб-интерфејс и API). При стартувањето, на алатките им се предаваат низа задолжителни и незадолжителни флагови. Ќе ги издвојам основните од нив:

• -m: пат до фајлот на моделот .gguf
• -p: промпт, барање до моделот под наводници
• -ngl број: број на слоеви на моделот што се испраќаат на графичката картичка
• -ngl 99: ги испраќа сите слоеви на невронската мрежа на графичкиот чип RTX
• -c број: големина на контекстниот прозорец (меморијата на разговорот). Стандардно е 512, а за целосна комуникација подобро е да се постави 2048, 4096 или изворниот лимит на моделот. Тука истовремено спаѓаат: системскиот промпт + историјата на преписката + вашето тековно прашање + идниот одговор на моделот. Директно влијае врз потрошувачката на видео меморија (VRAM) или RAM при стартувањето.
• -n број: максимален број токени што моделот може да ги создаде одеднаш. Користете -1 ако сакате да добивате целосни, развиени одговори без присилно отсекување на текстот.
• -t број: број на нишки на процесорот (актуелно при работа на CPU, за графичка картичка не е актуелно). Се препорачува да се постави еднакво на бројот на физички (не виртуелни) јадра на вашиот процесор. На пример, ако имате 8-јадрен процесор со 16 нишки, се препорачува да се постави -t 8. Прекумерниот број нишки само ќе го забави генерирањето.

Во најминималниот случај, треба да ја наведеме опцијата -m, која го поставува патеката до фајлот на моделот.

Да го разгледаме стартувањето на чат со моделот на примерот на претходно преземениот модел DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf. Всушност, тука имаме две варијанти:

• Стартување на CPU За да се стартува моделот на CPU во режим на еднократен одговор (без разговор), доволно е со помош на опцијата -p да се наведе барањето до моделот под наводници:

# Windows
llama-cli.exe -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -p "Вашиот промпт"


# Linux
./llama-cli -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -p "Вашиот промпт"

При тоа, дури и ако имате инсталирано CUDA-верзија на llama.cpp, стандардно програмата секогаш ги остава сите 100 отсто од слоевите на моделот на процесорот и во оперативната меморија (RAM). Графичката картичка во тој случај нема да биде искористена.

• Стартување на графичка картичка За да се добие максимална брзина, треба сите слоеви на моделот да се пренесат во видео меморијата со помош на аргументот -ngl (или --n-gpu-layers). За целосно пренесување на GPU (GPU Offloading) се применува параметарот -ngl 99:

# Windows
llama-cli.exe -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -ngl 99 -p "Вашиот промпт"

# Linux
./llama-cli -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -ngl 99 -p "Вашиот промпт"

При тоа, тука се користи бројот 99, но во принцип бројот на слоеви може да биде поинаков. На пример, за 8B модел од архитектурата Qwen обично е доволно да се постават 40 до 50 слоеви (флагот -ngl 99 автоматски ќе ги пренесе апсолутно сите достапни слоеви). Ако меморијата на графичката картичка е мала, намалете го овој број за да остане дел од слоевите во RAM-от.

Треба да се напомене дека дури и по добивањето на одговорот, програмата не завршува. Може веднаш во конзолата да внесеме нови барања и моделот исто така ќе одговара на нив. При тоа, моделот го помни контекстот (во рамките на контекстниот прозорец). Затоа, во текот на чатот може да се навраќаме или да се повикуваме на претходно направените барања во рамките на еден чат.

За излез од чатот, внесете ја командата /exit.

Стартување на моделот на локален сервер llama.cpp

За стартување на локален API-сервер со помош на llama.cpp се користи одделен извршен фајл, llama-server, кој доаѓа заедно со другите алатки во составот на llama.cpp, чие инсталирање беше објаснето погоре. Овој сервер е целосно компатибилен со стандардите на OpenAI API, што овозможува да се поврзе со кои било дополнителни интерфејси (на пример, Open WebUI, LM Studio) или да се користи во сопствените скрипти на Python, JS и cURL.

За основно стартување, извршете ја во конзолата следнава команда:

# Windows
llama-server.exe -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -ngl 99 -c 4096 --host 127.0.0.1 --port 8080

# Linux
./llama-server -m DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -ngl 99 -c 4096 --host 127.0.0.1 --port 8080

Клучни тагови за серверот:

• --host 127.0.0.1: серверот ќе биде достапен само на вашиот компјутер (localhost). Ако треба да се отвори пристап за други уреди во локалната мрежа, наведете 0.0.0.0.
• --port 8080: портот на кој ќе се подигне серверот (може да се смени на кој било слободен).
• -c 4096: крајно важен параметар за серверот. Тој ја задава големината на контекстот што серверот ќе го подели меѓу вашите барања.

По стартувањето, серверот ќе го слуша портот 8080. Со него може да се работи на неколку начини.

roka@Roka:~/llama.cpp$ ./llama-server -m /llm/DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf -ngl 99 -c 4096 --host 127.0.0.1 --port 8080

0.00.206.576 I log_info: verbosity = 3 (adjust with the `-lv N` CLI arg)

0.00.206.578 I device_info:

0.00.299.036 I - CUDA0 : NVIDIA GeForce RTX 3090 (24114 MiB, 23829 MiB free)

0.00.299.046 I - CPU : 11th Gen Intel(R) Core(TM) i9-11900K (31755 MiB, 31755 MiB free)

0.00.299.102 I system_info: n_threads = 8 (n_threads_batch = 8) / 24 | CUDA : ARCHS = 860 | USE_GRAPHS = 1 | PEER_MAX_BATCH_SIZE = 128 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX_VNNI = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | BMI2 = 1 | LLAMAFILE = 1 | OPENMP = 1 | REPACK = 1 |

0.00.299.108 I srv llama_server: n_parallel is set to auto, using n_parallel = 4 and kv_unified = true

0.00.299.862 I srv init: using 23 threads for HTTP server

0.00.300.174 I srv start: binding port with default address family

0.00.301.314 I srv llama_server: loading model

0.00.301.421 I srv load_model: loading model '/llm/DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf'

0.00.301.478 I common_init_result: fitting params to device memory ...

0.00.301.478 I common_init_result: (for bugs during this step try to reproduce them with -fit off, or provide --verbose logs if the bug only occurs with -fit on)

0.00.638.133 W load: control-looking token: 128247 '</s>' was not control-type; this is probably a bug in the model. its type will be overridden

Преку веб-интерфејсот во прелистувачот (најлесниот начин)

Развивачите на llama.cpp вградиле во серверот готов лесен веб-интерфејс. За да работите со него, без да ја затворате конзолата со стартуваниот сервер, отворете кој било прелистувач и одете на адресата

http://127.0.0.1:8080

. Пред вас ќе се отвори практичен прозорец за чат, каде што може да се комуницира со моделот, да се менуваат параметрите на генерирањето и да се тестираат промптовите.

Преку cURL (барања од конзолата)

Може да испратите стандардно JSON-барање во формат на OpenAI преку друг прозорец на терминалот:

curl http://localhost:8080/v1/chat/completions \

-H "Content-Type: application/json" \

-d '{

"messages": [

{"role": "user", "content": "Колку е 2 + 2?"}

]

}'

Адресата „/v1/chat/completions“ е стандардна патека (ендпоинт) создаден од компанијата OpenAI за нејзините модели (како ChatGPT). Развивачите на llama.cpp и llama-server ја додадоа оваа патека во својот сервер заради целосна компатибилност со екосистемата на OpenAI.

Со помош на опцијата -d поставуваме низа параметри со помош на нотацијата JSON. Овие параметри се стандарден формат за означување на разговорот (Chat History). Тие се потребни за да ја разбере невронската мрежа содржината на разговорот: кој точно зборува и што точно било кажано:

• messages: листа (низа) што ја содржи целата историја на преписката. Во JSON се означува со аглести загради [...]. Внатре во оваа листа се предаваат пораките по редослед: од најстарите кон најновите. Со предавањето на историјата, ѝ овозможувате на моделот да помни за што станувало збор во претходните реплики.
• role (улога). Овој параметар покажува кој е авторот на пораката. Постојат три основни улоги:
  • system (системска инструкција), ги задава правилата на однесување, карактерот или ограничувањата за вештачката интелигенција. Го задава контекстот пред почетокот на комуникацијата.
  • user (корисник), тоа се вашите реплики, прашања и команди.
  • assistant (асистент), тоа се одговорите на самата невронска мрежа. Треба да се додаваат во листата messages ако сакате да го продолжите разговорот, за да ги помни моделот своите претходни одговори.
• content (содржина). Тоа е текстот на самата порака. Тука се запишува конкретното прашање на корисникот, инструкцијата на системот или текстот на одговорот на асистентот.

Пример на барање би можел да изгледа вака:

roka@Roka:~$ curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{

"messages": [

{"role": "user", "content": "Колку е 2 + 2?"}

]

}'

{"choices":[{"finish_reason":"stop","index":0,"message":{"role":"assistant","content":"\nсекако, пријатно е да се знае дека умееш да решаваш едноставни задачки! Одговорот е едноставен: **2 + 2 = 4**. ","reasoning_content":"\nХм, корисникот прашува \"Колку е 2 + 2?\" на македонски. Ова е едноставно аритметичко прашање, но важно е да се одговори јасно и пријателски. \n\nИнтересно, зошто токму ова прашање? Можеби, ..................................

Ако сакате да го продолжите разговорот земајќи го предвид контекстот, вашето JSON-барање би изгледало вака:

{

"messages": [

{"role": "system", "content": "Ти си шеф-готвач. Одговарај кратко."},

{"role": "user", "content": "Здраво! Што да зготвам од јајца?"},

{"role": "assistant", "content": "Направи класичен омлет со зеленчук."},

{"role": "user", "content": "А колку минути да го пржам?"}

]

}

Преку Python (за развивачи)

Најлесниот и најсовремениот начин да се напише таква скрипта на Python е да се користи официјалната библиотека openai. Бидејќи llama-server целосно го имитира API на OpenAI, библиотеката ќе работи со него без проблеми.

Прво, да го инсталираме официјалниот клиент во терминалот:

pip install openai

Понатаму, да создадеме фајл llama_test.py и да го вметнеме во него следниов код. Тој го користи стандардниот клиент и е подесен на вашата локална адреса:

from openai import OpenAI

# Го иницијализираме клиентот, наведувајќи ја адресата на вашиот llama-server

# API-клучот за локалниот сервер може да биде кој било (на пример, "not-needed").

client = OpenAI(

base_url="http://localhost:8080/v1",

api_key="not-needed"

)

# Испраќаме барање во формат на чат

response = client.chat.completions.create(

model="local-model", # llama-server ќе го игнорира името и ќе го користи вчитаниот модел

messages=[

{"role": "system", "content": "Ти си краток и прецизен асистент."},

{"role": "user", "content": "Објасни во две реченици што е гравитација."}

]

)

# Го печатиме добиениот одговор на екранот

print(response.choices[0].message.content)

Ако не сакате да ја инсталирате библиотеката openai, може да испратите обично HTTP-барање преку стандардниот (или вградениот во Python) модул requests. Прво, проверете дали е инсталиран:

pip install requests

Потоа, за испраќање на барањето може да го користиме следниов код:

import requests

url = "http://localhost:8080/v1/chat/completions"

headers = {"Content-Type": "application/json"}

data = {

"messages": [

{"role": "user", "content": "Напиши ми една мотивациона порака на денот."}

]

}

response = requests.post(url, headers=headers, json=data)

result = response.json()

# Го извлекуваме текстот на одговорот од структурата JSON

print(result["choices"][0]["message"]["content"])

 

[Isak Keyten]

Ти аплаудирам на трудот што го внесуваш во овие едукациони теми/постови и не сакам да сум хејтер ама фали доза на иронија тука што е очигледна а тоа е: во доба на ВИ, сите овие теми и туториали се беспотребни баш ради тоа што имаме ВИ

Или со ризик да испадне не смешно “this could've been a prompt".

 

[Fatal1ty_]

Стартување на модел со помош на библиотеката Hugging Face Transformers

Погоре беа разгледани различни начини за стартување на LLM моделите со помош на различни алатки, LM Studio, Ollama, llama.cpp. Уште еден начин за работа со LLM претставува библиотеката Hugging Face Transformers („трансформери“), напишана во Python. Нејзината главна разлика е: Transformers е библиотека за развивачи и истражувачи, додека LM Studio, Ollama и llama.cpp (и слични алатки) се готови екосистеми и алатки за оптимизирано при локално стартување.

Обично Transformers се користи при создавање на нов производ со вештачка интелигенција, при дообучување на невронската мрежа или при истражување на нејзината внатрешност. Ако пак задачата е едноставно да се стартува готов модел локално за чат или за интеграција во готова апликација, тогаш подобро е да се избере Ollama, LM Studio или llama.cpp. Сепак, не можеше воопшто да не се разгледа Hugging Face Transformers. Згора на тоа, тие имаат свои предности:

• Апсолутна флексибилност. Достапна е целосна контрола врз архитектурата. Може да се менуваат слоевите, логиката на генерирањето, токенизаторите и да се додаваат прилагодени функции.
• Поддршка за кои било тежини. Моделите се стартуваат во оригинален формат (FP32, FP16, BF16). Не треба да се чека заедницата да ги конвертира во форматите GGUF или EXL2.
• Идеална за обука. Тоа е стандард за fine-tune (дообучување), тренирање на модели од нула и научни истражувања. Опонентите (Ollama, LM Studio) не се наменети за тоа.
• Лесна интеграција во Python. Библиотеката нативно се вградува во сложени enterprise-пајплајни, веб-сервиси (FastAPI) и аналитички скрипти.
• Поддршка за мултимодалност. Од една библиотека може да се стартуваат текстуални, аудио-, видео- и дифузиони модели.

Но исто така треба да се напоменат и недостатоците на Hugging Face Transformers:

• Огромни барања за VRAM. Стандардно, моделите работат без строга компресија. За стартување на условен модел од 70B параметри во оригинален квалитет FP16 ќе бидат потребни неколку скапи серверски графички картички (A100/H100). На пример, погоре беше разгледано користењето на моделот DeepSeek-R1-0528-Qwen3-8B со квантизација, кој во принцип би можел да се користи и на графички картички од 16 GB. Сепак, во чиста форма (без компресија), при стартување преку трансформери, за DeepSeek-R1-0528-Qwen3-8B 16 GB на графичката картичка веќе се малку.
• Сложено подесување на квантизацијата. За да се стартува моделот на домашен компјутер, ќе треба рачно да се приклучуваат дополнителни библиотеки. Во llama.cpp и Ollama тоа работи од сам старт.
• Ниска брзина на CPU. Инференсот на процесори без користење на GPU во Transformers работи крајно бавно.
• Отсуство на готов интерфејс. Нема вграден чат ниту готов локален сервер. Се треба да се пишува со код на Python.
• Праг за влез. Потребни се знаења за Python, PyTorch и, во понапредните сценарија, разбирање на подесувањата на архитектурата на трансформерите.

Директна споредба со алтернативите

Критериум	Hugging Face Transformers	llama.cpp	Ollama	LM Studio
Основен формат	PyTorch (.bin, .safetensors)	GGUF	GGUF (сопствен манифест)	GGUF
Интерфејс	Само код (Python)	Конзола (CLI)	Конзола / API	Готов интуитивен GUI (чат)
Работа на CPU	Многу бавно	Максимално оптимизирано	Оптимизирано	Оптимизирано
Потрошувачка на RAM	Многу висока	Минимална (за сметка на квантизацијата)	Минимална	Средна (GUI зема ресурси)
Сфера на примена	Развој, истражувања, обука	Нискониво оптимизација, IoT	Развој на апликации, микросервиси	Обични корисници, тестови на модели

• llama.cpp го надминува Transformers во продуктивноста на потрошувачки хардвер (особено на процесори и на Apple Silicon) благодарение на јадрото напишано на C/C++ и на квантизацијата.
• Ollama и LM Studio се изградени врз основа на llama.cpp. Тие го надминуваат Transformers во брзината на поставување: стартувањето на моделот таму одзема буквално една команда или еден клик.

Да го разгледаме користењето на библиотеката Hugging Face transformers на пример за стартување на моделот deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B · Hugging Face (достапен на адресата deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B · Hugging Face). Ова е доста слаб модел, избран само заради целите на демонстрација на работата со трансформерите: тој има околу 1,5 милијарда параметри и релативно мала големина. Сепак, го избрав намерно, бидејќи за работа со овој модел е доволна графичка картичка (NVIDIA) со минимум 6 GB видео меморија (VRAM) за работа без квантизација (во формат BF16/FP16).

Подготовка на окружувањето

За работа со моделот, пред се, потребно е да се инсталира Python.

На Linux (Ubuntu/Debian) исто така треба да се инсталираат низа пакети:

sudo apt update && sudo apt install python3-pip python3-venv git -y

Исто така, проверете дали во системот се инсталирани драјверите за NVIDIA и CUDA Toolkit (на Linux, инсталацијата може да се провери со помош на командата nvidia-smi, која треба да ја покажува актуелната верзија на CUDA).

Создавање на виртуелно окружување и инсталирање на библиотеките

Создадете изолирана папка за проектот, за да не се судираат зависностите со други програми. Одете во конзолата во оваа папка и извршете ги следниве команди:

# Создаваме и активираме виртуелно окружување
# Linux/MacOS
python3 -m venv venv

# Windows
python -m venv venv

Оваа команда ќе создаде виртуелно окружување „venv“. Ќе го ативираме ова окружување со помош на командата:

# Активирање на Linux:

source venv/bin/activate

# Активирање на Windows:

.\venv\Scripts\activate

По активирањето на окружувањето, лево треба да се појави ознаката (venv), која кажува дека сме внатре во активираното виртуелно окружување:

roka@Roka:/transformers$ python3 -m venv venv

roka@Roka:/transformers$ source venv/bin/activate

(venv) roka@Roka:/transformers$

[code]

Сега да ги инсталираме потребните библиотеки:

[code]

# Инсталирање на PyTorch со поддршка за CUDA (за GPU)

pip3 install torch --index-url https://download.pytorch.org/whl/cu132

# Инсталирање на библиотеките од екосистемата на Hugging Face и забрзување

pip3 install transformers accelerate

За што одговара секоја зависност:

• torch (PyTorch): основната рамка за длабоко учење, потребна за пресметки на GPU и за поддршка на форматот на податоци bfloat16.
• transformers: библиотеката од Hugging Face, која ја содржи самата архитектура на моделот Qwen/DeepSeek, токенизаторот и алатките за генерирање текст.
• accelerate: алатка од Hugging Face, која е потребна за автоматска и правилна распределба на слоевите на моделот во меморијата на графичката картичка (device_map="cuda" или "auto").

Скрипта за стартување на моделот (Python)

Обично на моделот на huggingface се наведува како да се стартува моделот, различните аспекти на стартувањето и различните поставки. Сепак, некои моменти се заеднички за различните модели. Понатаму, да го разгледаме минималниот код потребен за стартување на моделот deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B · Hugging Face. За таа цел, да создадеме во папката на проектот фајл app.py (името на фајлот е произволно) со следниов код:

from transformers import pipeline

# Вчитување на пајплајнот (ќе го преземе моделот при првото стартување)

pipe = pipeline("text-generation", model="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", device_map="auto")

# Испраќање на барањето

prompt = "Колку планети има во Сончевиот систем? Одговори кратко."

# Добивање на одговорот

outputs = pipe(prompt, max_new_tokens=100)

# Печатење на резултатот

print(outputs[0]["generated_text"])

Накратко да ја разгледаме оваа скрипта. За да се поедностави стартувањето на моделот, го применуваме методот pipeline() од библиотеката transformers, тој ослободува од потребата рачно да се подесува токенизаторот (Tokenizer) и самиот модел. Овој метод прифаќа три параметри:

• "text-generation": тоа е името на конкретната задача (task) во екосистемот на библиотеката Hugging Face Transformers. Кога ја предавате оваа низа во pipeline(), и укажувате на библиотеката која точно архитектура и логика на работа треба да се изгради околу избраниот модел. Под хауба, благодарение на овој параметар, се избира класата на моделот, во овој случај класата AutoModelForCausalLM (модели што го предвидуваат секој следен збор врз основа на претходните). Исто така, ова ја определува логиката на обработката: го подесува конвертерот така што тој прима на влез текст (или чат-структура), го претвора во токени, го стартува генерирањето на нови токени се додека моделот не даде токен за запирање (EOS), и враќа назад готов текст. Со менување на овој параметар, може да се решаваат сосема различни задачи со соодветни модели. На пример, наместо генерирање текст, може да се предаваат следниве вредности:
  • "sentiment-analysis": класификација на текст (определување на тонот: позитивен/негативен).
  • "translation": превод од еден јазик на друг.
  • "summarization": сумирање (создавање краток преглед на текстот).
  • "automatic-speech-recognition": препознавање на говор (претворање на аудио во текст). За работа со сите современи LLM (вклучувајќи DeepSeek, Llama, Qwen, Mistral) во pipeline секогаш се користи токму "text-generation".
• model="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B": тоа е идентификаторот на моделот во системот на huggingface. Идентификаторот се совпаѓа со адресата на моделот на huggingface: deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B · Hugging Face
• device_map="auto": покажува каде да се вршат пресметките. Вредноста „auto“ автоматски ја користи графичката картичка (GPU) ако ја има, или го стартува моделот на процесорот (CPU). А вредноста „cuda“, на пример, ја користи графичката картичка.

При првото стартување, скриптата автоматски ќе ги преземе тежините на моделот (во овој случај околу 4 GB) од Hugging Face, па затоа стартувањето на моделот може да одземе одредено време. По преземањето на фајловите на моделот од huggingface ќе започне извршувањето.

Треба да се напомене дека за секој модел може да се применуваат свои одделни поставки, информациите за кои обично се наведуваат на страницата на моделот на huggingface, но општиот процес ќе биде сличен. На пример, вчитувањето на моделот Qwen2.5-7B-Instruct, кој е достапен на адресата Qwen/Qwen2.5-7B-Instruct · Hugging Face:

# Вчитување на моделот Qwen/Qwen2.5-7B-Instruct

pipe = pipeline("text-generation", model="Qwen/Qwen2.5-7B-Instruct", device_map="auto")

Рачно поставување на чат

Во примерот погоре, за работа со моделот се применуваше методот pipeline, кој всушност претставува „се во едно“, создадена заради максимална едноставност. Сепак, честопати во примерите и во описите на моделите на huggingface може да се види друг метод на стартување на моделите, кој се применува кога е важна флексибилноста на архитектурата и детална контрола.

Овој метод претпоставува користење на директно вчитување (AutoModel + AutoTokenizer) и дава целосна контрола врз процесот, ги гледате и ги контролирате сите фаза: токенизацијата, самото генерирање и декодирањето.

Во исто време, овој метод носи повеќе код: треба да се пишува многу шаблонски код (вчитување, пренесување на GPU преку .to(), декодирање). Додека pipeline сам го создава токенизаторот, сам ги пренесува податоците на GPU и сам ги декодира токените во текст на излезот.

Ајде да го измениме кодот во фајлот app.py на следниов начин:

[/code=python]

from transformers import AutoModelForCausalLM, AutoTokenizer

import torch

model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"

# Го вчитуваме токенизаторот и моделот во видео меморијата

tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(

model_id,

dtype="auto",

device_map="auto"

)

# Ја формираме историјата на пораките
messages = [

{"role": "user", "content": "Колку планети има во Сончевиот систем? Одговори кратко."}

]

# Го применуваме шаблонот на чатот

prompt = tokenizer.apply_chat_template(

messages,

add_generation_prompt=True,

tokenize=False

)

# Го токенизираме текстот на барањето и го пренесуваме на графичката картичка

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# Го генерираме одговорот

outputs = model.generate(

**inputs,

max_new_tokens=512 # Лимит на токени за одговорот (вклучувајќи ја низата зборови)

)

# Го декодираме и го печатиме резултатот

# За да се прикаже убаво во конзолата и процесот на „мислите“ и самиот одговор

full_output = tokenizer.decode(outputs[0], skip_special_tokens=False)

# Го отсекуваме самиот промпт од исписот, за да го видиме само генерирањето на моделот

generated_text = full_output[len(tokenizer.decode(inputs["input_ids"][0], skip_special_tokens=False)):]

print(generated_text)

[/code]

Овој код повторно ги вчитува и ги стартува јазичниот модел DeepSeek-R1-Distill-Qwen-1.5B за генерирање на одговор на текстуалното барање. Најпрво доаѓа импортот на библиотеките и наведувањето на моделот:

from transformers import AutoModelForCausalLM, AutoTokenizer

import torch

model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"

AutoTokenizer и AutoModelForCausalLM претставуваат алатки за автоматско вчитување на токенизаторот и на архитектурата на моделот според неговото име. model_id ја определува патеката до складиштето на моделот на Hugging Face.

Понатаму доаѓа вчитувањето на токенизаторот и на моделот:

tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(

model_id,

dtype="auto",

device_map="auto"

)

tokenizer или токенизаторот го претвора текстот во броеви разбирливи за компјутерот (токени) и обратно. dtype="auto": и укажува на библиотеката transformers автоматски да го избере типот на податоци за тежините на моделот врз основа на тоа како тој бил зачуван од авторот на Hugging Face. device_map="auto": автоматски го распределува моделот на достапниот хардвер (на пример, на графичката картичка CUDA ако ја има, инаку на CPU).

Следната фаза е подготовка на структурата на барањето:

messages = [

{"role": "user", "content": "Колку планети има во Сончевиот систем? Одговори кратко."}

]

prompt = tokenizer.apply_chat_template(

messages,

add_generation_prompt=True,

tokenize=False

)

messages: листа во стандарден формат на чат (улога и текст на пораката). apply_chat_template: ја претвора листата на пораки во единствена низа со системски тагови (на пример, <User>, <｜Assistant｜>) што моделот очекува да ги види. add_generation_prompt=True: додава на крајот маркер дека понатаму треба да следува одговорот на моделот.

Понатаму доаѓа токенизацијата и испраќањето на уредот:

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

Овој код го претвора текстуалниот промпт во тензори на PyTorch (return_tensors="pt") и ги пренесува тие податоци на истиот уред каде што се наоѓа самиот модел (.to(model.device)).

Потоа се извршува генерирањето на текстот:

outputs = model.generate(

**inputs,

max_new_tokens=512

)

Методот generate го тера моделот да ги предвидува следните токени. А параметарот max_new_tokens=512 ја ограничува максималната должина на одговорот. Моделите DeepSeek-R1 најпрво пишуваат низа на расудување (Reasoning), па затоа лимитот мора да биде доволен за мислите и за финалниот одговор.

И на крајот, декодирањето и чистењето на исписот:

full_output = tokenizer.decode(outputs[0], skip_special_tokens=False)

generated_text = full_output[len(tokenizer.decode(inputs["input_ids"][0], skip_special_tokens=False)):]

print(generated_text)

tokenizer.decode: ги претвора генерираните броеви-токени назад во читлив текст. skip_special_tokens=False ги задржува таговите како <think>, за да го гледате процесот на расудување на моделот. generated_text = full_output[...]: овој исечок го отстранува изворниот промпт од финалниот текст, оставајќи го само чистиот одговор на моделот.

Поставување на патеките до моделот

Стандардно, ако моделот отсуствува на локалниот компјутер, тогаш тој се презема и се зачувува во домашната папка на корисникот, во фолдерот .cache/huggingface ($HOME/.cache/huggingface). Сепак, може и сами да ги преземеме сите потребни фајлови и да ги сместиме на произволно место во датотечниот систем, и оттаму да ги приклучуваме во апликацијата.

За да ги преземеме фајловите рачно и да го стартуваме моделот локално, треба да ги преземеме основните конфигурациски фајлови, тежините и фајловите на токенизаторот, а потоа да го наведеме локалната патека во кодот. Кои фајлови да се преземат? Да влеземе на страницата на моделот на Hugging Face (таб Files and versions) и да ги преземеме следниве фајлови:

• Тежини на моделот: model.safetensors (или сите фајлови .safetensors, ако се поделени на делови).
• Конфигурација: config.json, generation_config.json.
• Токенизатор: tokenizer.json, tokenizer_config.json, special_tokens_map.json.

По преземањето на фајловите, да ги сместиме сите преземени фајлови во една папка. На пример, во тековната папка каде што се наоѓа скриптата app.py, да создадеме директориум models, а во него поддиректориум DeepSeek-R1-Distill-Qwen-1.5B, и потоа во создадениот директориум models/DeepSeek-R1-Distill-Qwen-1.5B/ да ги сместиме сите преземени фајлови.

Понатаму, во кодот, наместо името на моделот од складиштето, да го наведеме апсолутната или релативната патека до папката со преземените фајлови:

from transformers import pipeline

# Наведете го патот до папката каде што се наоѓаат преземените фајлови

local_model_path = "./models/DeepSeek-R1-Distill-Qwen-1.5B/"

# Вчитување на пајплајнот од локалната папка

pipe = pipeline(

"text-generation",

model=local_model_path,

device_map="auto"

)

# Испраќање на барањето

prompt = "Колку планети има во Сончевиот систем? Одговори кратко."

# Добивање на одговорот

outputs = pipe(prompt, max_new_tokens=250, return_full_text=False)

# Печатење на резултатот

print(outputs[0]["generated_text"])

Заклучок

Ок, тоа е тоа на долго и детално. Да сумираме! изборот на конкретна алатка зависи од вашите цели, вашето ниво на искуство и хардверот со кој располагате. За обичен чат и запознавање со технологијата доволна е LM Studio или Ollama, за фина контрола и интеграција во сопствени скрипти подобри се llama.cpp и Transformers.

Најважно е што сите овие алатки овозможуваат моделите да се стартуваат локално, на сопствен хардвер, што значи целосна приватност на податоците и независност од надворешни сервиси.

Светот на локалните јазични модели се развива со неверојатно темпо, па алатките, форматите и самите модели постојано се менуваат и подобруваат, но основните принципи што ги разгледавме тука ќе ви послужат како стабилна основа за понатамошно истражување и работа во оваа возбудлива област.