Startseite>Programmierbezogen>AI-Quellcode
Herunterladen

Erhöhen Sie die generative KI-Leistung mit Friendli

CI-Status

Der Friendli Client bietet eine praktische Schnittstelle zur Interaktion mit Endpunktdiensten der Friendli Suite, der ultimativen Lösung für die Bereitstellung generativer KI-Modelle. Es ist auf Flexibilität und Leistung ausgelegt und unterstützt sowohl synchrone als auch asynchrone Vorgänge, sodass Sie leistungsstarke KI-Funktionen einfach in Ihre Anwendungen integrieren können.

Installation

Um mit Friendli zu beginnen, installieren Sie das Client-Paket mit pip : 

pip install friendli-client

Wichtig

Sie müssen die Umgebungsvariable FRIENDLI_TOKEN festlegen, bevor Sie die Client-Instanz mit client = Friendli() initialisieren. Alternativ können Sie beim Erstellen des Clients den Wert Ihres persönlichen Zugriffstokens als token -Argument angeben, etwa so: 

 from friendli import Friendli

client = Friendli ( token = "YOUR PERSONAL ACCESS TOKEN" )

Freundliche serverlose Endpunkte

Friendli Serverless Endpoint bietet eine einfache Click-and-Play-Schnittstelle für den Zugriff auf beliebte Open-Source-Modelle wie Llama 3.1. Mit der Pay-per-Token-Abrechnung ist dies ideal zum Erkunden und Experimentieren.

Um mit Modellen zu interagieren, die von serverlosen Endpunkten gehostet werden, geben Sie den Modellcode an, den Sie im model verwenden möchten. Eine Liste der verfügbaren Modellcodes und deren Preise finden Sie in der Preistabelle. 

 from friendli import Friendli

client = Friendli ()

chat_completion = client . chat . completions . create (
    model = "meta-llama-3.1-8b-instruct" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
)
print ( chat_completion . choices [ 0 ]. message . content )

Friendli Dedizierte Endpunkte

Mit Friendli Dedicated Endpoints können Sie Ihre benutzerdefinierten generativen KI-Modelle auf dedizierten GPU-Ressourcen ausführen.

Um mit dedizierten Endpunkten zu interagieren, geben Sie die Endpunkt-ID im model an. 

 import os
from friendli import Friendli

client = Friendli (
    team_id = os . environ [ "TEAM_ID" ],  # If not provided, default team is used.
    use_dedicated_endpoint = True ,
)

chat_completion = client . chat . completions . create (
    model = os . environ [ "ENDPOINT_ID" ],
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
)
print ( chat_completion . choices [ 0 ]. message . content )

Freundlicher Container

Friendli Container ist perfekt für Benutzer, die LLMs lieber innerhalb ihrer eigenen Infrastruktur bereitstellen möchten. Durch die Bereitstellung der Friendli Engine in Containern auf Ihren On-Premise- oder Cloud-GPUs können Sie die vollständige Kontrolle über Ihre Daten und Abläufe behalten und so Sicherheit und Einhaltung interner Richtlinien gewährleisten. 

 from friendli import Friendli

client = Friendli ( base_url = "http://0.0.0.0:8000" )

chat_completion = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
)
print ( chat_completion . choices [ 0 ]. message . content )

Asynchrone Nutzung 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ()

async def main () -> None :
    chat_completion = await client . chat . completions . create (
        model = "meta-llama-3.1-8b-instruct" ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me how to make a delicious pancake" ,
            }
        ],
    )
    print ( chat_completion . choices [ 0 ]. message . content )


asyncio . run ( main ())

Streaming-Nutzung 

 from friendli import Friendli

client = Friendli ()

stream = client . chat . completions . create (
    model = "meta-llama-3.1-8b-instruct" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
    stream = True ,
)
for chunk in stream :
    print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )

Der asynchrone Client ( AsyncFriendli ) verwendet dieselbe Schnittstelle, um die Antwort zu streamen. 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ()

async def main () -> None :
    stream = await client . chat . completions . create (
        model = "meta-llama-3.1-8b-instruct" ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me how to make a delicious pancake" ,
            }
        ],
        stream = True ,
    )
    async for chunk in stream :
        print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )


asyncio . run ( main ())

Erweiterte Nutzung

Senden von Anfragen an LoRA-Adapter

Wenn Ihr Endpunkt ein Multi-LoRA-Modell bereitstellt, können Sie eine Anfrage an einen der Adapter senden, indem Sie die Adapterroute im model angeben.

Geben Sie für Friendli Dedicated Endpoints die Endpunkt-ID und die Adapterroute getrennt durch einen Doppelpunkt ( : ) an. 

 import os
from friendli import Friendli

client = Friendli (
    team_id = os . environ [ "TEAM_ID" ],  # If not provided, default team is used.
    use_dedicated_endpoint = True ,
)

chat_completion = client . lora . completions . create (
    model = f" { os . environ [ 'ENDPOINT_ID' ] } : { os . environ [ 'ADAPTER_ROUTE' ] } " ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
)

Geben Sie für Friendli Container einfach den Adapternamen an. 

 import os
from friendli import Friendli

client = Friendli ( base_url = "http://0.0.0.0:8000" )

chat_completion = client . lora . completions . create (
    model = os . environ [ "ADAPTER_NAME" ],
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
)

Verwendung der gRPC-Schnittstelle

Wichtig

gRPC wird nur von Friendli Container unterstützt und nur die Streaming-API von v1/completions ist verfügbar.

Wenn Frienldi Container im gPRC-Modus ausgeführt wird, kann der Client mit dem gRPC-Server interagieren, indem er ihn mit dem Argument use_grpc=True initialisiert. 

 from friendli import Friendli

client = Friendli ( base_url = "0.0.0.0:8000" , use_grpc = True )

stream = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
    stream = True ,  # Only streaming mode is available
)

for chunk in stream :
    print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )

Konfigurieren des HTTP-Clients

Der Client verwendet httpx zum Senden von HTTP-Anfragen. Sie können den angepassten httpx.Client bei der Initialisierung Friendli bereitstellen. 

 import httpx
from friendli import Friendli

with httpx . Client () as client :
    client = Friendli ( http_client = http_client )

Für den asynchronen Client können Sie httpx.AsyncClient bereitstellen. 

 import httx
from friendli import AsyncFriendli

with httpx . AsyncClient () as client :
    client = AsyncFriendli ( http_client = http_client )

Konfigurieren des gRPC-Kanals 

 import grpc
from friendli import Friendli

with grpc . insecure_channel ( "0.0.0.0:8000" ) as channel :
    client = Friendli ( use_grpc = True , grpc_channel = channel )

Sie können dieselbe Schnittstelle für den asynchronen Client verwenden. 

 import grpc . aio
from friendli import AsyncFriendli

async with grpc . aio . insecure_channel ( "0.0.0.0:8000" ) as channel :
    client = AsyncFriendli ( use_grpc = True , grpc_channel = channel )

Ressourcen verwalten

Der Friendli-Client bietet mehrere Methoden zur Verwaltung und Freigabe von Ressourcen.

Schließen des Clients

Sowohl der Friendli als auch AsyncFriendli Client können während ihrer Lebensdauer Netzwerkverbindungen oder andere Ressourcen halten. Um sicherzustellen, dass diese Ressourcen ordnungsgemäß freigegeben werden, sollten Sie entweder die Methode close() aufrufen oder den Client innerhalb eines Kontextmanagers verwenden. 

 from friendli import Friendli

client = Friendli ()

# Use the client for various operations...

# When done, close the client to release resources
client . close ()

Für den asynchronen Client ist das Muster ähnlich: 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ()

# Use the client for various async operations...

# When done, close the client to release resources
await client . close ()

Sie können den Kontextmanager auch verwenden, um den Client automatisch zu schließen und Ressourcen freizugeben, wenn der Block verlassen wird, was die Ressourcenverwaltung sicherer und bequemer macht. 

 from friendli import Friendli

with Friendli () as client :
    ...

Für asynchrone Nutzung: 

 import asyncio
from friendli import AsyncFriendli

async def main ():
    async with AsyncFriendli () as client :
        ...


asyncio . run ( main ())

Streaming-Antworten verwalten

Bei der Verwendung von Streaming-Antworten ist es wichtig, die HTTP-Verbindung nach Abschluss der Interaktion ordnungsgemäß zu schließen. Standardmäßig wird die Verbindung automatisch geschlossen, sobald alle Daten aus dem Stream verbraucht wurden (dh wenn die for-Schleife das Ende erreicht). Wenn das Streaming jedoch aufgrund von Ausnahmen oder anderen Problemen unterbrochen wird, bleibt die Verbindung möglicherweise offen und wird erst freigegeben, wenn sie durch den Müll gesammelt wird. Um sicherzustellen, dass alle zugrunde liegenden Verbindungen und Ressourcen ordnungsgemäß freigegeben werden, ist es wichtig, die Verbindung explizit zu schließen, insbesondere wenn das Streaming vorzeitig beendet wird. 

 from friendli import Friendli

client = Friendli ()

stream = client . chat . completions . create (
    model = "meta-llama-3.1-8b-instruct" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
    stream = True ,
)

try :
    for chunk in stream :
        print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
finally :
    stream . close ()  # Ensure the stream is closed after use

Für asynchrones Streaming: 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ()

async def main ():
    stream = await client . chat . completions . create (
        model = "meta-llama-3.1-8b-instruct" ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me how to make a delicious pancake" ,
            }
        ],
        stream = True ,
    )

    try :
        async for chunk in stream :
            print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
    finally :
        await stream . close ()  # Ensure the stream is closed after use

asyncio . run ( main ())

Sie können den Kontextmanager auch verwenden, um den Client automatisch zu schließen und Ressourcen freizugeben, wenn der Block verlassen wird, was die Ressourcenverwaltung sicherer und bequemer macht. 

 from friendli import Friendli

client = Friendli ()

with client . chat . completions . create (
    model = "meta-llama-3.1-8b-instruct" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
    stream = True ,
) as stream :
    for chunk in stream :
        print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )

Für asynchrones Streaming: 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ()

async def main ():
    async with await client . chat . completions . create (
        model = "meta-llama-3.1-8b-instruct" ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me how to make a delicious pancake" ,
            }
        ],
        stream = True ,
    ) as stream :
        async for chunk in stream :
            print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )

asyncio . run ( main ())

Abbrechen eines gRPC-Streams

Wenn Sie die gRPC-Schnittstelle mit Streaming verwenden, möchten Sie möglicherweise einen laufenden Stream-Vorgang abbrechen, bevor er abgeschlossen ist. Dies ist besonders nützlich, wenn Sie den Stream aufgrund einer Zeitüberschreitung oder einer anderen Bedingung stoppen müssen.

Für synchrones gRPC-Streaming: 

 from friendli import Friendli

client = Friendli ( base_url = "0.0.0.0:8000" , use_grpc = True )

stream = client . chat . completions . create (
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me how to make a delicious pancake" ,
        }
    ],
    stream = True ,
)

try :
    for chunk in stream :
        print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
except SomeException :
    stream . cancel ()  # Cancel the stream in case of an error or interruption

Für asynchrones gRPC-Streaming: 

 import asyncio
from friendli import AsyncFriendli

client = AsyncFriendli ( base_url = "0.0.0.0:8000" , use_grpc = True )

async def main ():
    stream = await client . chat . completions . create (
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me how to make a delicious pancake" ,
            }
        ],
        stream = True ,
    )

    try :
        async for chunk in stream :
            print ( chunk . choices [ 0 ]. delta . content or "" , end = "" , flush = True )
    except SomeException :
        stream . cancel ()  # Cancel the stream in case of an error or interruption

asyncio . run ( main ())

CLI-Beispiele

Sie können die Generierungs-APIs auch direkt mit der CLI aufrufen. 

friendli api chat-completions create 
  -g " user Tell me how to make a delicious pancake " 
  -m meta-llama-3.1-8b-instruct

Für weitere Informationen zum Befehl friendli führen Sie friendli --help in Ihrer Terminal-Shell aus. Dadurch erhalten Sie eine detaillierte Liste der verfügbaren Optionen und Gebrauchsanweisungen.

Tipp

Schauen Sie sich unsere offizielle Dokumentation an, um mehr zu erfahren!

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle