CANON_112024 CANON_112024 CANON_112024

NVIDIA NIM: príklady využitia AI mikroslužieb vo vami vyvíjaných aplikáciách

0

NVIDIA NIM (Nvidia Inference Microservices) je prostredie založené na mikroslužbách optimalizované pre rýchle rozhodovanie na báze AI. Prináša revolúciu do spôsobu nasadzovania generatívnej AI. Môžu to byť LLM modely, ktoré môžete jednoducho integrovať do vašich aplikácií.

Vo videu je postup vytvorenia aplikácií prezentovaných v tomto článku

Mikroslužby sú malé aplikácie, ktoré sú úzko špecializované na určitú funkciu. Výhodou mikroslužieb  je že ich môžete vyvíjať testovať a nasadzovať nezávisle. V praxi to znamená, že funkciu, ktorú vykonáva mikroslužba môžete vytvoriť a odladiť izolovane a potom je pripravená na integrovanie do komplexnejšieho systému. Pre AI systémy môže byť model ako jedna mikroslužba, údaje môže poskytovať druhá mikroslužba a tretia mikroslužba môže poskytovať výsledky v požadovanej forme. Každá mikroslužba môže byť vytvorená v inom prostredí a v inom programovacom jazyku a môže bežať pod iným operačným systémom.  

NVIDIA NIM sú mikroslužby využívajúce výpočtový výkon grafických kariet NVIDIA a funkcie knižnice CUDA pre typické AI úlohy ako je generovanie textu, rozpoznávanie obrazu, či rozhodovanie. Používateľ cez webové rozhranie požiada server aby vygeneroval text, ten aktivuje engine na generovanie textu a následne text doručí používateľa. Na vzájomnú interakciu sa využívajú API a rozhrania na výmenu informácií medzi jednotlivými modulmi.

Praktické pokusy odporúčam začať na https://build.nvidia.com/ Po vytvorení konta získate 1000 kreditov, čo stačí na preskúmanie viacerých modelov. Na stránke je ponuka rôznych open source modelov. Vľavo sú typy úloh: Reasoning, Vision, Visual Design, Retrieval, Speech, Biology, Simulation, Gaming, Healthcare, Industrial. Nájdete tam aj rôzne varianty obľúbených LLM modelov Llama. My použijeme model Llama 3.1, konkrétne meta / llama-3.1-8b-instruct ktorý nájdeme v zložke Reasoning. Možnosti modelov si môžete vyskúšať v okne Preview. V ľavom okne píšete text a v pravom okne môžete vidieť ako sa vaše zadanie integruje do kódu. Následne môžete model nasadiť do vlastnej infraštruktúry cez Docker kontejner. V záložke Docker sú pokyny a príkazy na spustenie kontajnera vo vašom prostredí.

Najskôr si musíte vytvoriť účet. Môžete sa zaregistrovať pomocou obchodného e-mailu na prístup k NIM prostredníctvom podnikovej licencie NVIDIA alebo osobného e-mailu na bezplatný prístup.

Ak chcete využívať NVIDIA NIM vytvorte si vývojársky účet a prihláste sa. Ako nefiremný používateľ získate 1000 bezplatných API kreditov, možnosť hostovať NIM na vašej infraštruktúre a podporu formou komunitného vývojárskeho fóra. Spomínaných 1000 kreditov v praxi znamená 1000 výziev pre LLM z vašej aplikácie.

Ako prvý ukážem príklad jednoduchej aplikácie v programovacom jazyku Python, ktorú budem editovať a spúšťať vo vývojovom prostredí Visual Studio Code. Stačí skopírovať kód z pravého okna stránky na ktorej ste model skúšali. V mojom prípade som tam mal zadanie: Napíš program v Pythone na utriedenie čísla. Čísla sú uložené v CSV súbore.  Prekopíroval som kód

from openai import OpenAI
client = OpenAI(
  base_url = "https://integrate.api.nvidia.com/v1",
  api_key = "$API_KEY_REQUIRED_IF_EXECUTING_OUTSIDE_NGC"
)
 
completion = client.chat.completions.create(
  model="meta/llama-3.1-8b-instruct",
  messages=[{"role":"user","content":"Write Python code for numbers sorting. Numbers are in CSV file"}],
  temperature=0.2,
  top_p=0.7,
  max_tokens=1024,
  stream=True
)
 
for chunk in completion:
  if chunk.choices[0].delta.content is not None:
    print(chunk.choices[0].delta.content, end="")

Vo fragmente kódu je riadok

api_key = "$API_KEY_REQUIRED_IF_EXECUTING_OUTSIDE_NGC"

do ktorého je potrebné zadať API_KEY. Na jeho získanie stačí kliknúť na link Get API key v hornej časti prevej polovice obrazovky nad kódom.  Kód si skopírujte a môžete prejsť do vývojového prostredia, v mojom prípade do Visual Studio Code.

Druhý príklad bude komplexnejší. Vytvoríme webovú aplikáciu bežiacu v prostredí streamlit, ktorá bude mať pole pre zadanie výzvy, pole pre zobrazenie odpovede a tlačidlo na aktivovanie skenovania adresára s dokumentmi vo formáte PDF. Jazykový model bude pre odpovede využívať informácie z PDF dokumentov uložených v adresári. AI modely typu Llama najlepšie fungujú v angličtine, preto najskôr použijem dokumenty v angličtine a potom pre zaujímavosť uložím do adresára, s ktorým bude LLM pracovať aj niekoľko PDF dokumentov v slovenčine.   

Potrebujeme mať nainštalovanú platformu Anaconda. Postup inštalácie nájdete vo videu

Vo Visual Studio Code budeme pracovať aj v okne terminálu. Vytvoríme virtuálne prostredie napríklad s názvom env_nmi:

conda create -p env_nim python==3.10 -y

Následne virtuálne prostredie aktivujeme. Príkaz pre aktivovanie sa nám zobrazí počas inštalovania prostredia

V príklade budeme potrebovať niekoľko knižníc, konkrétne openai, python-dotenv, streamlit, langchain_nvidia_ai_endpoints, langchain_community, faiss-cpu a pypdf. Môžete skúsiť dať ich do súboru requirements.txt

openai
python-dotenv
streamlit
langchain_nvidia_ai_endpoints
langchain_community
faiss-cpu
pypdf

a aktivovať ich inštaláciu príkazom

pip install -r requirements.txt

Ja som ich radšej inštaloval postupne príkazom pip install aby som mohol sledovať, či sa všetko správne nainštalovalo.

Framework Streamlit umožňuje prezentovať dáta prostredníctvom interaktívnej webovej aplikácie. Streamlit je k dispozícii zdarma a využíva programovací jazyk Python. Link na tutorial

Inštaluje sa príkazom

pip install streamlit

Program v Pythone budeme spúšťať príkazom

streamlit run priklad.py

Knižnica FAISS (Facebook AI Similarity Search) umožňuje vývojárom rýchlo vyhľadávať multimediálne dokumentov, ktoré sú si navzájom podobné. Rieši obmedzenia tradičných vyhľadávacích nástrojov na vyhľadávanie, ktoré sú optimalizované pre vyhľadávania založené na hash, a poskytuje škálovateľnejšie funkcie vyhľadávania podobnosti. Pomocou FAISS môžu vývojári vyhľadávať multimediálne dokumenty spôsobmi, ktoré sú štandardnými databázovými nástrojmi založenými na SQL  neefektívne alebo nemožné.  FAISS je implementovaný v C++, s voliteľným rozhraním Python a podporou GPU cez CUDA.

https://docs.streamlit.io/develop/tutorials/llms/build-conversational-apps

Kompletná zdrojovka. NVIDIA_API_KEY je v súbore.env

import streamlit as sl
import os
from dotenv import load_dotenv
from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings, ChatNVIDIA
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.embeddings import OllamaEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain.chains import create_retrieval_chain
from langchain_community.vectorstores import FAISS  #Facebook AI Similarity Search
from langchain_community.document_loaders import PyPDFDirectoryLoader
 
 
 
load_dotenv()
os.environ['NVIDIA_API_KEY']=os.getenv("NVIDIA_API_KEY")
llm = ChatNVIDIA(model="meta/llama-3.1-8b-instruct")
 
def vector_embedding():
    if "vectors" not in sl.session_state:
        sl.session_state.embeddings=NVIDIAEmbeddings()
        sl.session_state.loader=PyPDFDirectoryLoader("./Documents")
        sl.session_state.docs=sl.session_state.loader.load()
        sl.session_state.text_splitter=RecursiveCharacterTextSplitter(chunk_size=700,chunk_overlap=50)
        sl.session_state.final_documents=sl.session_state.text_splitter.split_documents(sl.session_state.docs[:30])
        sl.session_state.vectors=FAISS.from_documents(sl.session_state.final_documents,sl.session_state.embeddings) #vector OpenAI embeddings
 
 
sl.title("NVIDIA NIM Príklad1")
prompt=ChatPromptTemplate.from_template(
"""
Poskytujem výstup len na základe poskytnutého kontextu.
Otázku sformulujte čo najvýstižnejšoe
{context}
Questions:{input}
 
"""
)
 
 
prompt1=sl.text_input("Zadanie (v angličtine) týkajúce sa dokumentov)")
if sl.button("Skenovanie dokumentov"):
    vector_embedding()
    sl.write("Skenovanie dokumentov ukončené")
 
 
if prompt1:
    document_chain=create_stuff_documents_chain(llm,prompt)
    retriever=sl.session_state.vectors.as_retriever()
    retrieval_chain=create_retrieval_chain(retriever,document_chain)
    response=retrieval_chain.invoke({'input':prompt1})
    sl.write(response['answer'])
 
    # streamlit expander
    with sl.expander("Relevantné dokumenty"):
        # relevantné info
        for i, doc in enumerate(response["context"]):
            sl.write(doc.page_content)
            sl.write("--------------------------------")

Luboslav Lacko

Všetky autorove články
NVIDIA NIM Microservices

Pridať komentár

Mohlo by vás zaujímať

Mohlo by vás zaujímať