Page d'accueil>Lié à la programmation>Code Source AI
Télécharger

Boostez le service IA génératif avec Friendli

Statut de l'IC

Le client Friendli offre une interface pratique pour interagir avec les services de point de terminaison fournis par Friendli Suite, la solution ultime pour servir des modèles d'IA génératifs. Conçu pour la flexibilité et les performances, il prend en charge les opérations synchrones et asynchrones, facilitant ainsi l'intégration de puissantes capacités d'IA dans vos applications.

Installation

Pour démarrer avec Friendli, installez le package client en utilisant pip : 

pip install friendli-client

Important

Vous devez définir la variable d'environnement FRIENDLI_TOKEN avant d'initialiser l'instance client avec client = Friendli() . Alternativement, vous pouvez fournir la valeur de votre jeton d'accès personnel comme argument token lors de la création du client, comme ceci : 

 from friendli import Friendli

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

Points de terminaison sans serveur Friendli

Friendli Serverless Endpoint offre une interface simple, cliquez et jouez, pour accéder aux modèles open source populaires comme Llama 3.1. Avec la facturation au paiement par jeton, c'est idéal pour l'exploration et l'expérimentation.

Pour interagir avec des modèles hébergés par des points de terminaison sans serveur, fournissez le code du modèle que vous souhaitez utiliser dans l'argument model . Reportez-vous au tableau de prix pour une liste des codes de modèles disponibles et leurs prix. 

 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 )

Points de terminaison dédiés Friendli

Les points de terminaison dédiés Friendli vous permettent d'exécuter vos modèles d'IA génératifs personnalisés sur des ressources GPU dédiées.

Pour interagir avec des points de terminaison dédiés, fournissez l’ID du point de terminaison dans l’argument model . 

 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 )

Conteneur amical

Friendli Container est parfait pour les utilisateurs qui préfèrent servir des LLM au sein de leur propre infrastructure. En déployant le moteur Friendli dans des conteneurs sur vos GPU sur site ou cloud, vous pouvez garder un contrôle total sur vos données et opérations, garantissant ainsi la sécurité et la conformité aux politiques internes. 

 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 )

Utilisation asynchrone 

 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 ())

Utilisation du streaming 

 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 )

Le client asynchrone ( AsyncFriendli ) utilise la même interface pour diffuser la réponse. 

 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 ())

Utilisation avancée

Envoi de requêtes aux adaptateurs LoRA

Si votre point de terminaison dessert un modèle Multi-LoRA, vous pouvez envoyer une requête à l'un des adaptateurs en fournissant la route de l'adaptateur dans l'argument model .

Pour les points de terminaison dédiés Friendli, fournissez l’ID du point de terminaison et la route de l’adaptateur séparés par deux points ( : ). 

 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" ,
        }
    ],
)

Pour Friendli Container, fournissez simplement le nom de l’adaptateur. 

 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" ,
        }
    ],
)

Utiliser l'interface gRPC

Important

gRPC n'est pris en charge que par Friendli Container, et seule l'API de streaming de v1/completions est disponible.

Lorsque Frienldi Container s'exécute en mode gPRC, le client peut interagir avec le serveur gRPC en l'initialisant avec l'argument use_grpc=True . 

 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 )

Configuration du client HTTP

Le client utilise httpx pour envoyer des requêtes HTTP. Vous pouvez fournir le httpx.Client personnalisé lors de l'initialisation Friendli . 

 import httpx
from friendli import Friendli

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

Pour le client asynchrone, vous pouvez fournir httpx.AsyncClient . 

 import httx
from friendli import AsyncFriendli

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

Configuration du canal gRPC 

 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 )

Vous pouvez utiliser la même interface pour le client asynchrone. 

 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 )

Gestion des ressources

Le client Friendli propose plusieurs méthodes pour gérer et libérer des ressources.

Fermeture du client

Les clients Friendli et AsyncFriendli peuvent conserver des connexions réseau ou d'autres ressources au cours de leur durée de vie. Pour garantir que ces ressources sont correctement libérées, vous devez soit appeler la méthode close() , soit utiliser le client dans un gestionnaire de contexte. 

 from friendli import Friendli

client = Friendli ()

# Use the client for various operations...

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

Pour le client asynchrone, le modèle est similaire : 

 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 ()

Vous pouvez également utiliser le gestionnaire de contexte pour fermer automatiquement le client et libérer les ressources lorsque le bloc est quitté, ce qui en fait un moyen plus sûr et plus pratique de gérer les ressources. 

 from friendli import Friendli

with Friendli () as client :
    ...

Pour une utilisation asynchrone : 

 import asyncio
from friendli import AsyncFriendli

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


asyncio . run ( main ())

Gestion des réponses en continu

Lorsque vous utilisez des réponses en streaming, il est crucial de fermer correctement la connexion HTTP une fois l'interaction terminée. Par défaut, la connexion est automatiquement fermée une fois que toutes les données du flux ont été consommées (c'est-à-dire lorsque la boucle for atteint la fin). Cependant, si le streaming est interrompu par des exceptions ou d'autres problèmes, la connexion peut rester ouverte et ne sera pas libérée tant qu'elle n'aura pas été récupérée. Pour garantir que toutes les connexions et ressources sous-jacentes sont correctement libérées, il est important de fermer explicitement la connexion, en particulier lorsque le streaming est interrompu prématurément. 

 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

Pour le streaming asynchrone : 

 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 ())

Vous pouvez également utiliser le gestionnaire de contexte pour fermer automatiquement le client et libérer les ressources lorsque le bloc est quitté, ce qui en fait un moyen plus sûr et plus pratique de gérer les ressources. 

 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 )

Pour le streaming asynchrone : 

 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 ())

Annulation d'un flux gRPC

Lorsque vous utilisez l'interface gRPC avec le streaming, vous souhaiterez peut-être annuler une opération de flux en cours avant qu'elle ne se termine. Ceci est particulièrement utile si vous devez arrêter le flux en raison d'un délai d'attente ou d'une autre condition.

Pour le streaming gRPC synchrone : 

 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

Pour le streaming gRPC asynchrone : 

 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 ())

Exemples CLI

Vous pouvez également appeler les API de génération directement avec CLI. 

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

Pour plus d'informations sur la commande friendli , exécutez friendli --help dans le shell de votre terminal. Cela vous fournira une liste détaillée des options disponibles et des instructions d'utilisation.

Conseil

Consultez notre documentation officielle pour en savoir plus !

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout