Hogyan használjuk az Open WebUI-t és építünk intelligens modelleket: Részletes útmutató

Az Open WebUI felület egy komplex, interaktív eszköz, amely lehetővé teszi számunkra, hogy különböző mesterséges intelligencia (AI) modelleket építsünk és teszteljünk. A folyamat az első bejelentkezéstől kezdve a modellek finomhangolásáig számos lépést tartalmaz, amelyek közül az egyik legfontosabb a megfelelő funkciók konfigurálása és a kívánt modell kiválasztása. Az alábbiakban bemutatott lépések segítenek abban, hogy hatékonyan és gyorsan elérjük a kívánt eredményeket a legújabb Open WebUI verziókban.

Amikor először lépünk be az Open WebUI felületére, az első dolog, amit meg kell tennünk, az a regisztráció. Ehhez kattintsunk a Sign_up linkre, ahol be kell írnunk a szükséges adatokat, például egy helyi felhasználónevet és jelszót, amelyek kizárólag a szerverhez kapcsolódnak. A regisztráció után a Create Account gombra kattintva véglegesíthetjük a fiók létrehozását. Ezt követően beléphetünk a felületre.

A Functions menü hiányában az Open WebUI felületén a funkciók konfigurálása némileg változott. A menü tetején található + ikon segítségével új funkciókat hozhatunk létre, amelyeket elnevezhetünk és leírással is elláthatunk. Egy példaként, hozzunk létre egy „RAG” nevű funkciót, és másoljuk be a következő kódot a szövegdobozba:
https://github.com/ibm-granite-community/granite-retrieval-agent/blob/main/granite_autogen_rag.py. Ezután kattintsunk a Save gombra a képernyő alján, hogy elmentsük a beállításokat.

A legfrissebb IBM Granite3-Dense modell kiválasztása után az Open WebUI felületén a modell már elérhetővé válik, és a felhasználó lekérdezéseket küldhet neki. Például, ha egy általános kérdést teszünk fel a római birodalomról, a rendszer válaszolni fog, és a válaszokat megtekinthetjük a képernyőn. Ezen kívül, ha további modelleket szeretnénk tesztelni, egyszerűen váltsunk át a különböző verziók között.

A mesterséges intelligencia és gépi tanulás modellek használata közben felmerülhet, hogy milyen típusú adatokat kell betölteni a rendszerbe. Az Open WebUI felület lehetővé teszi különböző formátumú adatok importálását, például CSV fájlok használatával, amelyeket a rendszer feldolgoz és a megfelelő modellekhez rendel. A példák között szerepelnek a staff_resources.csv és a staff_demands.csv fájlok, amelyeket a rendszer különböző adatforrásokhoz rendelhet a modell futtatása előtt.

A modell építésének és testreszabásának következő lépése az adatfeldolgozó paraméterek beállítása. A Modelling Assistant segítségével a rendszer automatikusan javaslatokat tesz az analitikai forgatókönyvekre és célokra, amelyeket később személyre szabhatunk. Az egyes forgatókönyvekhez súlyokat rendelhetünk, hogy azok megfelelően tükrözzék az általunk kívánt elemzési eredményeket. Miután minden beállítást végrehajtottunk, a modell végrehajtásához kattintsunk a Finish gombra, és az eredményeket vizualizálhatjuk egy Vega Chart segítségével.

A folyamat során fontos figyelni a következőkre: Az Open WebUI felület verziója, amelyet használunk, jelentősen befolyásolja a funkciók elérhetőségét és azok működését. Az 0.5-ös verzióban például az Functions menü eltűnt, és a fejlesztők az új verziókban a funkcionalitást másképp implementálták. Továbbá, ha nem megfelelő hardver áll rendelkezésre (például csak CPU-t használunk GPU helyett), akkor a válaszidő megnövekedhet, és a rendszer lassabban reagálhat.

Hogyan optimalizálhatjuk a modelleket kvantálással és adatfeldolgozással?

A mesterséges intelligencia és a gépi tanulás világában az optimalizálás kulcsfontosságú szerepet játszik, különösen, amikor nagy nyelvi modelleket alkalmazunk. A kvantálás és az adatfeldolgozási technikák alkalmazása segíthet csökkenteni a számítási igényeket és javítani a modellek teljesítményét, miközben hatékonyan kezelhetők a memóriakapacitások és az erőforrások. Az alábbiakban bemutatott eljárás az egyik módja annak, hogy egy nagy nyelvi modellt finomhangoljunk és optimalizáljunk a felhasználás során.

Először is, az adatbetöltés során a timeit könyvtárat használjuk a kód végrehajtási idejének mérésére, hogy nyomon követhessük az adatbetöltési folyamat időtartamát. Ehhez az alábbi Python-kódot használjuk:

python
Copy code
import timeit
start_time = timeit.default_timer()
from datasets import load_dataset
dataset = load_dataset('alespalla/chatbot_instruction_prompts')
dataset_loadtime = timeit.default_timer() - start_time

A kvantálás egy fontos lépés a memóriahatékony működéshez, különösen akkor, ha a hardver korlátozott memóriával rendelkezik. A következő kódrészlet bemutatja, hogyan tölthetjük be a modellt kvantált formátumban:

python
Copy code
start_time = timeit.default_timer()
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
model_checkpoint = "ibm-granite/granite-3.0-2b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.float16
)
model = AutoModelForCausalLM.from_pretrained(
    model_checkpoint, quantization_config=bnb_config, device_map="auto"
)
model_loadtime = timeit.default_timer() - start_time

python
Copy code
from transformers import pipeline
import datasets
def pirateify(batch):
    prompts = [f"make it sound like a pirate said this, do not include any preamble or explanation only piratify the following: {response}" for response in batch['response']]

    inputs = tokenizer(prompts, return_tensors="pt", padding=True, truncation=True).to('cpu')

    outputs = model.generate(**inputs, max_new_tokens=256, do_sample=True, top_p=0.95, temperature=0.7)
    pirate_responses = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
    inputs = inputs.to('cpu')
    outputs = outputs.to('cpu')
    torch.cuda.empty_cache()

    return {'prompt': batch['prompt'], 'response': pirate_responses}

def filter_long_examples(example):
    prompt_tokens = tokenizer.tokenize(example['prompt'])
    response_tokens = tokenizer.tokenize(example['response'])
    return len(response_tokens) <= 200 and len(prompt_tokens) <= 50
train_filtered = dataset['train'].select(range(6000)).filter(filter_long_examples)

test_filtered = dataset['test'].select(range(500)).filter(filter_long_examples)

pirate_train = train_filtered.select(range(1500)).map(pirateify, batched=True, batch_size=64)

pirate_test = test_filtered.select(range(250)).map(pirateify, batched=True, batch_size=64)

pirate_dataset = datasets.DatasetDict({'train': pirate_train, 'test': pirate_test})

Ezeket a feldolgozott adatokat most már felhasználhatjuk a modell betanítására. Az adatok előkészítése mellett azonban szükség van egy alapvető tesztre is a modell funkcionalitásának ellenőrzésére. A következő Python-kód egy egyszerű sanity check-et végez, amelynek célja, hogy megbizonyosodjunk arról, hogy a modell képes értelmes választ adni a megadott kérdésekre.

python
Copy code
start_time = timeit.default_timer()

input_text = "<|user>What does 'inheritance' mean? \n<|assistant|>\n"
inputs = tokenizer(input_text, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
model_check_loadtime = timeit.default_timer() - start_time

A modell kimenete várhatóan az öröklődés objektumorientált programozásban való alkalmazásának magyarázatát adja. Ez egy alapvető ellenőrzés, amely biztosítja, hogy a modell megfelelően működik, mielőtt további finomhangolást végeznének rajta. Ezt követően az adatok és a modell további finomhangolása a kívánt alkalmazásra történhet.

A kvantálás és az adatok előkészítése mellett a modell finomhangolása kulcsfontosságú szerepet játszik a sikeres alkalmazásban. Az optimalizálás folyamatos figyelmet igényel, mivel a nagy nyelvi modellek teljesítménye gyakran a legapróbb paraméterek beállításaitól is függhet. Az adatok minősége, a modellek konfigurálásának módja, a finomhangolás és az alkalmazott technikák mind jelentős hatással lehetnek a végső eredményre.

Hogyan alkalmazható az IBM Watsonx Code Assistant a vállalati fejlesztési környezetekben?

A nagy nyelvi modellek (LLM) fejlesztésében és alkalmazásában fontos szerepet játszanak a különböző eszközök és könyvtárak, amelyek lehetővé teszik a modellek hatékony és pontos működését. Egy ilyen eszköz az LLM kompresszor Python könyvtár, amely képes egy nagy LLM-t sokkal kisebb verzióvá alakítani a GPTQ algoritmus alkalmazásával. Az ilyen típusú kvantálás lehetőséget ad arra, hogy a modellek kisebb memóriát igényeljenek, miközben megőrizzék a pontosságot, még akkor is, ha a rétegeken végzett kvantálás hibákat eredményezhet. A kvantálás célja, hogy minimalizálja a memóriahasználatot és csökkentse a szükséges számítási kapacitást, miközben a hibák korrigálására szolgáló hibajavítási mechanizmusok működnek.

A generatív AI kód asszisztens segíti a fejlesztőket abban, hogy gyorsabban és minőségibb kódot írjanak, miközben minimalizálják a hibákat és növelik a produktivitást. A rendszer a Visual Studio Code és az Eclipse integrált fejlesztői környezetekhez is elérhető, ahol a fejlesztők közvetlenül dolgozhatnak a kóddal, miközben a rendszer a legújabb fejlesztéseket és ajánlásokat biztosít számukra. Az IBM Watsonx Code Assistant ingyenes próbaverziója lehetőséget biztosít a fejlesztők számára, hogy kipróbálják az AI-alapú kódolási képességeket anélkül, hogy azonnal licencet vásárolnának. Az ingyenes próbaverzió során a felhasználók 15 ingyenes erőforrást (RU) kapnak 30 napig, amelyeket különböző feladatok végrehajtására használhatnak fel.

A fejlesztők számára a rendszer egyszerűsíti a kód generálását, különösen az olyan ismétlődő feladatok esetén, mint a konfigurációs fájlok kezelése, vagy az API-k integrálása. A rendszer egyébként képes figyelembe venni a különböző programozási nyelvek és technológiák specifikus igényeit, és így segít abban, hogy a generált kód a lehető leginkább kompatibilis legyen az adott környezettel és alkalmazással.

A legújabb verziók, mint a Granite-20B-Code-Base vagy a Granite-34B-Code-Base, nagyobb méretű modelleket és fejlettebb algoritmusokat tartalmaznak, amelyek még nagyobb pontosságot és gyorsaságot biztosítanak a kódgenerálás során. A jövőben várható, hogy az ilyen típusú rendszerek még inkább képesek lesznek alkalmazkodni a különböző iparágak igényeihez, és segíteni fogják a szoftverfejlesztést egy olyan dinamikus és gyorsan fejlődő környezetben, ahol az AI technológiák kulcsszerepet játszanak.

Hogyan zajlik a pontos és homályos deduplikációs technika alkalmazása a rosszindulatú programok kiszűrésére és a kódmodellek finomhangolására?

A modern mesterséges intelligencia (MI) modellek fejlesztése során az egyik legfontosabb tényező a betanítási adatok minősége és tisztasága. Az IBM Granite 3.0 modelljei különösen hangsúlyozzák a kód és más típusú adatok előfeldolgozását, hogy azok minél hatékonyabban és pontosabban szolgálják a gépi tanulást. Az egyik kulcsfontosságú módszer a "pontos" (exact) és "homályos" (fuzzy) deduplikáció alkalmazása, amely képes az ismétlődő vagy hasonló dokumentumokat kiszűrni, ezáltal optimalizálva a tanítási folyamatot.

A nagy nyelvi modellek, mint például az IBM Granite, alapvetően hatalmas mennyiségű adatot igényelnek a tanulási folyamatukhoz. Az adatok többsége az internetes forrásokból származik, ám ezen adatok között gyakran előfordulnak olyan elemek, amelyek nem kívánatosak vagy károsak lehetnek. A deduplikációs módszerek, mint az Exact és Fuzzy Deduplication, segítenek abban, hogy a modellek csak releváns és tiszta adatokat használjanak a tanuláshoz.

A pontos deduplikáció (Exact Deduplication) az egyik legelterjedtebb technika, amely során az IBM a SHA256 hash kódok segítségével azonosítja a teljesen megegyező dokumentumokat. Ez a módszer rendkívül hatékony, mivel képes gyorsan felismerni és eltávolítani azokat az adatokat, amelyek teljesen megegyeznek a rendszerben található többi rekorddal. A második lépés a homályos deduplikáció (Fuzzy Deduplication), amely olyan dokumentumokat is eltávolít, amelyek ugyan nem teljesen azonosak, de nagyon hasonlóak, például apró eltérésekkel rendelkező kódrészletek. Ezt úgy érik el, hogy először a dokumentumokat minhash-elve, majd a Lokálisan Érzékeny Hashing (LSH) segítségével azonosítják a hasonló fájlokat.

Ez a két lépéses eljárás lehetővé teszi, hogy a rendszer a lehető legtöbb ismétlődő és redundáns adatot eltávolítsa, ezáltal biztosítva, hogy a gépi tanulás minél hatékonyabb és gyorsabb legyen. Az IBM által alkalmazott minhash és LSH technikák olyan erős matematikai alapokon nyugszanak, amelyek segítségével azonosíthatóak a hasonló, de nem teljesen egyező dokumentumok, így a végső adatállomány a lehető legoptimálisabb lesz.

A kódmodellek fejlesztésében különösen fontos a megfelelő előfeldolgozás, hiszen a hibás, duplikált vagy nem kívánatos kódrészletek komoly problémákat okozhatnak a rendszer pontosságában. Az IBM Granite 3.0 modelljeihez használt eszközök, mint például a CodeParrot és a StarCoder, célzottan a kódok tisztítását szolgálják. A CodeParrot a Python kódok előfeldolgozására szolgál, eltávolítva a hibás vagy nem kívánt kódrészleteket. A StarCoder modell pedig képes különféle programozási nyelvek kódjait előkészíteni, miközben biztosítja, hogy a generált kód ne tartalmazzon hibákat vagy biztonsági rést.

Mindezek a módszerek elengedhetetlenek ahhoz, hogy a mesterséges intelligencia rendszerek valóban megbízhatóan és etikus módon működjenek. Az adatok tisztítása és előfeldolgozása nemcsak a hatékonyságot növeli, hanem hozzájárul a modell megbízhatóságához és biztonságához is.