Introductie

Realtime AI-systemen zijn sterk afhankelijk van snelle gevolgtrekkingen. Inference API's van marktleiders als OpenAI, Google en Azure maken snelle besluitvorming mogelijk. De Language Processing Unit (LPU)-technologie van Groq is een opvallende oplossing die de AI-verwerkingsefficiëntie verbetert. Dit artikel gaat in op de innovatieve technologie van Groq, de impact ervan op AI-inferentiesnelheden en hoe je deze kunt benutten met behulp van de Groq API.

leerdoelen

• Begrijp de Language Processing Unit (LPU)-technologie van Groq en de impact ervan op AI-inferentiesnelheden
• Leer hoe u de API-eindpunten van Groq kunt gebruiken voor realtime AI-verwerkingstaken met lage latentie
• Ontdek de mogelijkheden van de ondersteunde modellen van Groq, zoals Mixtral-8x7b-Instruct-v0.1 en Llama-70b, voor het begrijpen en genereren van natuurlijke taal
• Vergelijk en contrasteer het LPU-systeem van Groq met andere inferentie-API's, waarbij factoren als snelheid, efficiëntie en schaalbaarheid worden onderzocht

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Wat is Groq?

Opgericht in 2016, Groq is een in Californië gevestigde startup voor AI-oplossingen met het hoofdkantoor in Mountain View. Groq, gespecialiseerd in AI-inferentie met ultra-lage latentie, heeft de AI-computerprestaties aanzienlijk verbeterd. Groq is een prominente deelnemer op het gebied van AI-technologie, heeft zijn naam als handelsmerk geregistreerd en een mondiaal team samengesteld dat zich inzet voor het democratiseren van de toegang tot AI.

Taalverwerkingseenheden

Groq's Language Processing Unit (LPU), een innovatieve technologie, heeft tot doel de AI-computerprestaties te verbeteren, met name voor grote taalmodellen (LLM's). Het Groq LPU-systeem streeft ernaar om realtime ervaringen met lage latentie te leveren met uitzonderlijke inferentieprestaties. Groq behaalde meer dan 300 tokens per seconde per gebruiker op het Llama-2 70B-model van Meta AI, waarmee een nieuwe benchmark voor de sector werd gezet.

Het Groq LPU-systeem beschikt over ultra-lage latentiemogelijkheden die cruciaal zijn voor AI-ondersteuningstechnologieën. Het is specifiek ontworpen voor sequentiële en rekenintensieve GenAI-taalverwerking en presteert beter dan conventionele GPU-oplossingen, waardoor efficiënte verwerking wordt gegarandeerd voor taken zoals het creëren en begrijpen van natuurlijke taal.

Groq's GroqChip van de eerste generatie, onderdeel van het LPU-systeem, beschikt over een tensor-streamingarchitectuur die is geoptimaliseerd voor snelheid, efficiëntie, nauwkeurigheid en kosteneffectiviteit. Deze chip overtreft bestaande oplossingen en vestigt nieuwe records in fundamentele LLM-snelheid gemeten in tokens per seconde per gebruiker. Met plannen om binnen twee jaar 1 miljoen AI-inferentiechips in te zetten, toont Groq zijn toewijding aan het bevorderen van AI-versnellingstechnologieën.

Samenvattend vertegenwoordigt Groq's Language Processing Unit-systeem een ​​aanzienlijke vooruitgang in AI-computertechnologie, die uitstekende prestaties en efficiëntie biedt voor grote taalmodellen en tegelijkertijd innovatie op het gebied van AI stimuleert.

Lees ook: ML-model bouwen in AWS SageMaker

Aan de slag met Groq

Op dit moment levert Groq gratis te gebruiken API-eindpunten voor de grote taalmodellen die draaien op de Groq LPU – Language Processing Unit. Bezoek dit om aan de slag te gaan pagina en klik op inloggen. De pagina ziet er ongeveer zo uit als hieronder:

Klik op Inloggen en kies een van de juiste methoden om in te loggen bij Groq. Vervolgens kunnen we een nieuwe API zoals hieronder maken door op de knop API-sleutel maken te klikken

Wijs vervolgens een naam toe aan de API-sleutel en klik op “verzenden” om een ​​nieuwe API-sleutel aan te maken. Ga nu naar een code-editor/Colab en installeer de vereiste bibliotheken om Groq te gaan gebruiken.

!pip install groq

Met deze opdracht wordt de Groq-bibliotheek geïnstalleerd, waardoor we de grote taalmodellen kunnen afleiden die op de Groq LPU's draaien.

Laten we nu verder gaan met de code.

Code Implementatie

# Importing Necessary Libraries
import os
from groq import Groq

# Instantiation of Groq Client
client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

Dit codefragment vormt een Groq-clientobject voor interactie met de Groq API. Het begint met het ophalen van de API-sleutel uit een omgevingsvariabele met de naam GROQ_API_KEY en geeft deze door aan het argument api_key. Vervolgens initialiseert de API-sleutel het Groq-clientobject, waardoor API-aanroepen naar de grote taalmodellen binnen Groq Servers mogelijk zijn.

Onze LLM definiëren

llm = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a helpful AI Assistant. You explain ever 
            topic the user asks as if you are explaining it to a 5 year old"
        },
        {
            "role": "user",
            "content": "What are Black Holes?",
        }
    ],
    model="mixtral-8x7b-32768",
)

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

• De eerste regel initialiseert een llm-object, waardoor interactie met het Large Language Model mogelijk wordt, vergelijkbaar met de OpenAI Chat Completion API.
• De daaropvolgende code construeert een lijst met berichten die naar de LLM moeten worden verzonden, opgeslagen in de berichtenvariabele.
• Het eerste bericht kent de rol toe als ‘systeem’ en definieert het gewenste gedrag van de LLM om onderwerpen uit te leggen zoals dat zou gebeuren aan een 5-jarige.
• Het tweede bericht kent de rol toe als “gebruiker” en bevat de vraag over zwarte gaten.
• De volgende regel specificeert de LLM die moet worden gebruikt voor het genereren van het antwoord, ingesteld op "mixtral-8x7b-32768", een 32k context Mixtral-8x7b-Instruct-v0.1 Groot taalmodel toegankelijk via de Groq API.
• De uitvoer van deze code zal een reactie zijn van de LLM waarin zwarte gaten worden uitgelegd op een manier die geschikt is voor het begrip van een 5-jarige.
• Toegang tot de uitvoer volgt een vergelijkbare aanpak als het werken met het OpenAI-eindpunt.

uitgang

Hieronder ziet u de uitvoer die is gegenereerd door het Mixtral-8x7b-Instruct-v0.1 grote taalmodel:

De voltooiingen.create() object kan zelfs extra parameters opnemen, zoals temperatuur-, top_p en max_tokens.

Een reactie genereren

Laten we proberen een antwoord te genereren met deze parameters:

llm = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a helpful AI Assistant. You explain ever 
            topic the user asks as if you are explaining it to a 5 year old"
        },
        {
            "role": "user",
            "content": "What is Global Warming?",
        }
    ],
    model="mixtral-8x7b-32768",
    temperature = 1,
    top_p = 1,
    max_tokens = 256,
)

• temperatuur-: regelt de willekeur van reacties. Een lagere temperatuur leidt tot meer voorspelbare resultaten, terwijl een hogere temperatuur resulteert in meer gevarieerde en soms creatievere resultaten
• max_tokens: het maximale aantal tokens dat het model in één antwoord kan verwerken. Deze limiet zorgt voor rekenefficiëntie en resourcebeheer
• top_p: Een methode voor het genereren van tekst waarbij het volgende token wordt geselecteerd uit de waarschijnlijkheidsverdeling van de bovenste p meest waarschijnlijke tokens. Dit brengt exploratie en exploitatie tijdens de generatie in evenwicht

uitgang

Er is zelfs een optie om de reacties gegenereerd vanuit het Groq Endpoint te streamen. We hoeven alleen maar de stroom=Waar optie in het voltooiingen.create() object voor het model om de antwoorden te streamen.

Groq in Langchain

Groq is zelfs compatibel met LangChain. Download de bibliotheek om Groq in LangChain te gaan gebruiken:

!pip install langchain-groq

Met het bovenstaande wordt de Groq-bibliotheek geïnstalleerd voor LangChain-compatibiliteit. Laten we het nu in code uitproberen:

# Import the necessary libraries.
from langchain_core.prompts import ChatPromptTemplate
from langchain_groq import ChatGroq

# Initialize a ChatGroq object with a temperature of 0 and the "mixtral-8x7b-32768" model.
llm = ChatGroq(temperature=0, model_name="mixtral-8x7b-32768")

De bovenstaande code doet het volgende:

• Creëert een nieuw ChatGroq-object met de naam llm
• Stelt de temperatuur- parameter op 0, wat aangeeft dat de antwoorden voorspelbaarder zouden moeten zijn
• Stelt de modelnaam parameter naar “mixtral-8x7b-32768“, waarbij het te gebruiken taalmodel wordt gespecificeerd

# Definieer het systeembericht waarin de mogelijkheden van de AI-assistent worden geïntroduceerd.

# Define the system message introducing the AI assistant's capabilities.
system = "You are an expert Coding Assistant."

# Define a placeholder for the user's input.
human = "{text}"

# Create a chat prompt consisting of the system and human messages.
prompt = ChatPromptTemplate.from_messages([("system", system), ("human", human)])

# Invoke the chat chain with the user's input.
chain = prompt | llm

response = chain.invoke({"text": "Write a simple code to generate Fibonacci numbers in Rust?"})

# Print the Response.
print(response.content)

• De code genereert een chatprompt met behulp van de klasse ChatPromptTemplate.
• De prompt bestaat uit twee berichten: één van het ‘systeem’ (de AI-assistent) en één van de ‘mens’ (de gebruiker).
• Het systeembericht stelt de AI-assistent voor als een deskundige codeerassistent.
• Het menselijke bericht dient als tijdelijke aanduiding voor de invoer van de gebruiker.
• De llm-methode roept de llm-keten aan om een ​​antwoord te produceren op basis van de opgegeven prompt en de invoer van de gebruiker.

uitgang

Hier is de uitvoer gegenereerd door het Mixtral Large Language Model:

De Mixtral LLM genereert consequent relevante reacties. Het testen van de code in de Rust Playground bevestigt de functionaliteit ervan. De snelle reactie wordt toegeschreven aan de onderliggende Language Processing Unit (LPU).

Groq versus andere inferentie-API's

Het Language Processing Unit (LPU)-systeem van Groq heeft tot doel bliksemsnelle inferentiesnelheden te leveren voor Large Language Models (LLM's) en overtreft andere inferentie-API's zoals die van OpenAI en Azure. Het LPU-systeem van Groq is geoptimaliseerd voor LLM's en biedt mogelijkheden met ultralage latentie die cruciaal zijn voor AI-ondersteuningstechnologieën. Het pakt de belangrijkste knelpunten van LLM's aan, waaronder rekendichtheid en geheugenbandbreedte, waardoor snellere generatie van tekstreeksen mogelijk wordt.

In vergelijking met andere inferentie-API's is het LPU-systeem van Groq sneller, met de mogelijkheid om tot 18x ​​snellere inferentieprestaties te genereren op het LLMPrf Leaderboard van Anyscale in vergelijking met andere top cloudgebaseerde providers. Het LPU-systeem van Groq is ook efficiënter, met een single core-architectuur en synchrone netwerken die worden onderhouden bij grootschalige implementaties, waardoor automatische compilatie van LLM's en directe geheugentoegang mogelijk is.

De bovenstaande afbeelding toont benchmarks voor 70B-modellen. Bij het berekenen van de doorvoer van de uitvoertokens wordt het gemiddelde genomen van het aantal uitvoertokens dat per seconde wordt geretourneerd. Elke LLM-inferentieprovider verwerkt 150 verzoeken om resultaten te verzamelen, en de gemiddelde doorvoer van uitvoertokens wordt berekend op basis van deze verzoeken. Verbeterde prestaties van de LLM-inferentieprovider worden aangegeven door een hogere doorvoer van uitvoertokens. Het is duidelijk dat de outputtokens per seconde van Groq beter presteren dan veel van de weergegeven cloudproviders.

Conclusie

Concluderend: het Language Processing Unit (LPU)-systeem van Groq onderscheidt zich als een revolutionaire technologie op het gebied van AI-computing, die ongekende snelheid en efficiëntie biedt voor het verwerken van Large Language Models (LLM's) en het stimuleren van innovatie op het gebied van AI. Door gebruik te maken van zijn mogelijkheden met ultralage latentie en geoptimaliseerde architectuur, zet Groq nieuwe maatstaven voor inferentiesnelheden, waarmee hij beter presteert dan conventionele GPU-oplossingen en andere toonaangevende inferentie-API's. Met zijn inzet om de toegang tot AI te democratiseren en zijn focus op realtime ervaringen met lage latentie, staat Groq klaar om het landschap van AI-versnellingstechnologieën opnieuw vorm te geven.

Key Takeaways

• Het Language Processing Unit (LPU)-systeem van Groq biedt ongeëvenaarde snelheid en efficiëntie voor AI-inferentie, met name voor Large Language Models (LLM's), waardoor realtime ervaringen met lage latentie mogelijk zijn
• Het LPU-systeem van Groq, met de GroqChip, beschikt over ultra-lage latentiemogelijkheden die essentieel zijn voor AI-ondersteuningstechnologieën en presteert beter dan conventionele GPU-oplossingen
• Met plannen om binnen twee jaar 1 miljoen AI-inferentiechips in te zetten, toont Groq zijn toewijding aan het bevorderen van AI-versnellingstechnologieën en het democratiseren van de toegang tot AI
• Groq biedt gratis te gebruiken API-eindpunten voor grote taalmodellen die op de Groq LPU draaien, waardoor het voor ontwikkelaars toegankelijk wordt om in hun projecten te integreren
• De compatibiliteit van Groq met LangChain en LlamaIndex breidt de bruikbaarheid verder uit en biedt naadloze integratie voor ontwikkelaars die Groq-technologie willen gebruiken bij hun taalverwerkingstaken

Veelgestelde Vragen / FAQ

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.analyticsvidhya.com/blog/2024/03/getting-started-with-groq-api/