Inicio>Relacionado con la programación>Código Fuente de IA
Descargar

Potencia el servicio de IA generativa con Friendli

Estado del CI

Friendli Client ofrece una interfaz conveniente para interactuar con los servicios de punto final proporcionados por Friendli Suite, la solución definitiva para servir modelos de IA generativa. Diseñado para ofrecer flexibilidad y rendimiento, admite operaciones sincrónicas y asincrónicas, lo que facilita la integración de potentes capacidades de IA en sus aplicaciones.

Instalación

Para comenzar con Friendli, instale el paquete del cliente usando pip : 

pip install friendli-client

Importante

Debe configurar la variable de entorno FRIENDLI_TOKEN antes de inicializar la instancia del cliente con client = Friendli() . Alternativamente, puede proporcionar el valor de su token de acceso personal como argumento token al crear el cliente, así: 

 from friendli import Friendli

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

Puntos finales sin servidor Friendli

Friendli Serverless Endpoint ofrece una interfaz sencilla de hacer clic y reproducir para acceder a modelos populares de código abierto como Llama 3.1. Con la facturación de pago por token, esto es ideal para la exploración y la experimentación.

Para interactuar con modelos alojados en puntos finales sin servidor, proporcione el código del modelo que desea usar en el argumento model . Consulte la tabla de precios para obtener una lista de códigos de modelo disponibles y sus precios. 

 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 )

Puntos finales dedicados de Friendli

Los puntos finales dedicados de Friendli le permiten ejecutar sus modelos de IA generativos personalizados en recursos de GPU dedicados.

Para interactuar con puntos finales dedicados, proporcione el ID del punto final en el argumento 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 )

Contenedor amigable

Friendli Container es perfecto para usuarios que prefieren atender LLM dentro de su propia infraestructura. Al implementar Friendli Engine en contenedores en sus GPU locales o en la nube, puede mantener un control total sobre sus datos y operaciones, garantizando la seguridad y el cumplimiento de las políticas internas. 

 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 )

Uso asíncrono 

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

Uso de transmisión 

 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 )

El cliente asíncrono ( AsyncFriendli ) utiliza la misma interfaz para transmitir la respuesta. 

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

Uso avanzado

Envío de solicitudes a adaptadores LoRA

Si su punto final presta servicio a un modelo Multi-LoRA, puede enviar una solicitud a uno de los adaptadores proporcionando la ruta del adaptador en el argumento model .

Para los puntos finales dedicados de Friendli, proporcione el ID del punto final y la ruta del adaptador separados por dos puntos ( : ). 

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

Para Friendli Container, simplemente proporcione el nombre del adaptador. 

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

Usando la interfaz gRPC

Importante

gRPC solo es compatible con Friendli Container y solo está disponible la API de transmisión v1/completions .

Cuando Frienldi Container se ejecuta en modo gPRC, el cliente puede interactuar con el servidor gRPC inicializándolo con el argumento 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 )

Configurar el cliente HTTP

El cliente utiliza httpx para enviar solicitudes HTTP. Puede proporcionar el httpx.Client personalizado al inicializar Friendli . 

 import httpx
from friendli import Friendli

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

Para el cliente asíncrono, puede proporcionar httpx.AsyncClient . 

 import httx
from friendli import AsyncFriendli

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

Configurar el 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 )

Puede utilizar la misma interfaz para el cliente asíncrono. 

 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 )

Gestión de recursos

El cliente Friendli proporciona varios métodos para gestionar y liberar recursos.

Cerrar el cliente

Tanto los clientes Friendli como AsyncFriendli pueden mantener conexiones de red u otros recursos durante su vida. Para garantizar que estos recursos se liberen correctamente, debe llamar al método close() o utilizar el cliente dentro de un administrador de contexto. 

 from friendli import Friendli

client = Friendli ()

# Use the client for various operations...

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

Para el cliente asíncrono, el patrón es similar: 

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

También puede utilizar el administrador de contexto para cerrar automáticamente el cliente y liberar recursos cuando se sale del bloqueo, lo que lo convierte en una forma más segura y conveniente de administrar recursos. 

 from friendli import Friendli

with Friendli () as client :
    ...

Para uso asincrónico: 

 import asyncio
from friendli import AsyncFriendli

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


asyncio . run ( main ())

Administrar respuestas de transmisión

Cuando se utilizan respuestas en streaming, es fundamental cerrar correctamente la conexión HTTP una vez completada la interacción. De forma predeterminada, la conexión se cierra automáticamente una vez que se han consumido todos los datos de la transmisión (es decir, cuando el bucle for llega al final). Sin embargo, si la transmisión se ve interrumpida por excepciones u otros problemas, la conexión puede permanecer abierta y no se liberará hasta que se recoja la basura. Para garantizar que todas las conexiones y recursos subyacentes se liberen correctamente, es importante cerrar explícitamente la conexión, especialmente cuando la transmisión finaliza prematuramente. 

 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

Para transmisión asincrónica: 

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

También puede utilizar el administrador de contexto para cerrar automáticamente el cliente y liberar recursos cuando se sale del bloqueo, lo que lo convierte en una forma más segura y conveniente de administrar recursos. 

 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 )

Para transmisión asincrónica: 

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

Cancelar una transmisión gRPC

Cuando utilice la interfaz gRPC con transmisión, es posible que desee cancelar una operación de transmisión en curso antes de que se complete. Esto es particularmente útil si necesita detener la transmisión debido a un tiempo de espera o alguna otra condición.

Para transmisión gRPC sincrónica: 

 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

Para transmisión gRPC asincrónica: 

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

Ejemplos de CLI

También puede llamar a las API de generación directamente con CLI. 

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

Para obtener más información sobre el comando friendli , ejecute friendli --help en el shell de su terminal. Esto le proporcionará una lista detallada de las opciones disponibles e instrucciones de uso.

Consejo

¡Consulte nuestra documentación oficial para obtener más información!

Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo