Como usar o LLM CLI para implantar o modelo GPT-4o em gotas de GPU

Introdução

Com o surgimento de grandes modelos de linguagem (LLMs), está se tornando mais prático executar esses modelos de IA generativa na infraestrutura em nuvem. A DigitalOcean introduziu recentemente GPU Droplets, que permite aos desenvolvedores executar tarefas computacionalmente pesadas, como treinamento e implantação de LLMs com eficiência. Neste tutorial, você aprenderá a configurar e usar o LLM CLI e implantar o modelo GPT-4o da OpenAI em um Droplet GPU DigitalOcean usando a linha de comando.

LLM CLI é um utilitário de linha de comando e uma biblioteca Python para interagir com modelos de linguagem grande, tanto por meio de APIs remotas quanto de modelos que podem ser instalados e executados em sua própria máquina.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Uma conta DigitalOcean Cloud.
• Um GPU Droplet implantado e em execução.
• Familiaridade com a linha de comando do Linux. Para saber mais, você pode visitar este guia na cartilha de linha de comando do Linux.
• A ferramenta LLM CLI instalada em seu GPU Droplet.
• Uma chave de API OpenAI configurada para acessar o modelo GPT-4o.

Passo 1 - Configurar o Droplet GPU

1.Criar um novo projeto - Você precisará criar um novo projeto no painel de controle da nuvem e vinculá-lo a um GPU Droplet.

2.Criar um Droplet GPU - Faça login em sua conta DigitalOcean, crie um novo Droplet GPU e escolha AI/ML Ready como sistema operacional. Esta imagem do sistema operacional instala todos os drivers de GPU NVIDIA necessários. Você pode consultar nossa documentação oficial sobre como criar um GPU Droplet.

3.Adicione uma chave SSH para autenticação - Uma chave SSH é necessária para autenticar com o GPU Droplet e, ao adicionar a chave SSH, você pode fazer login no GPU Droplet a partir do seu terminal.

4.Finalizar e criar o GPU Droplet - Depois que todas as etapas acima forem concluídas, finalize e crie um novo GPU Droplet.

Passo 2 – Instalar Dependências

Assim que o GPU Droplet estiver pronto e implantado. Você pode usar SSH para o GPU Droplet a partir do seu terminal.

ssh root@<your-droplet-ip>

LLM CLI requer que Python e pip sejam instalados em seu GPU Droplet.

sudo apt install python3 python3-pip -y

Certifique-se de que seu GPU Droplet baseado em Ubuntu esteja atualizado:

sudo apt update && sudo apt upgrade -y

Etapa 3 - Instalar LLM CLI

Vamos instalar esta ferramenta CLI usando pip:

pip install llm

Vamos verificar a instalação:

llm --version

llm, version 0.16

Você pode usar o comando abaixo para obter uma lista de comandos llm:

llm --help

Usage: llm [OPTIONS] COMMAND [ARGS]...

  Access large language models from the command-line

  Documentation: https://llm.datasette.io/

  To get started, obtain an OpenAI key and set it like this:

      $ llm keys set openai
      Enter key: ...

  Then execute a prompt like this:

      llm 'Five outrageous names for a pet pelican'

Options:
  --version  Show the version and exit.
  --help     Show this message and exit.

Commands:
  prompt*       Execute a prompt
  aliases       Manage model aliases
  chat          Hold an ongoing chat with a model.
  collections   View and manage collections of embeddings
  embed         Embed text and store or return the result
  embed-models  Manage available embedding models
  embed-multi   Store embeddings for multiple strings at once
  install       Install packages from PyPI into the same environment as LLM
  keys          Manage stored API keys for different models
  logs          Tools for exploring logged prompts and responses
  models        Manage available models
  openai        Commands for working directly with the OpenAI API
  plugins       List installed plugins
  replicate     Commands for working with models hosted on Replicate
  similar       Return top N similar IDs from a collection
  templates     Manage stored prompt templates
  uninstall     Uninstall Python packages from the LLM environment

Passo 4 – Gerenciamento de chaves de API

Muitos modelos LLM requerem uma chave API. Essas chaves de API podem ser fornecidas a esta ferramenta usando vários mecanismos diferentes.

Neste tutorial, como você está implantando o modelo GPT-4o da OpenAI, você pode obter uma chave de API para os modelos de linguagem da OpenAI na página de chaves de API em seu site.

Depois de ter a chave API pronta e salva, use o comando abaixo para armazenar e salvar a chave API:

llm keys set openai

Você será solicitado a inserir a chave assim:

Enter key:<paste_your_api_key>

Etapa 5 – Implantar e executar o modelo GPT-4o usando LLM CLI

LLM CLI vem com um plugin padrão para se comunicar com a API do OpenAI. Ele usa o modelo gpt-3.5-turbo como plugin padrão. Você também pode instalar plug-ins LLM para usar modelos de outros fornecedores, como Claude, gpt4all, llama etc, incluindo modelos licenciados abertamente para execução direta. seu próprio computador.

Todos esses plug-ins ajudam você a executar LLMs diretamente em seu próprio computador.

Para verificar a lista de plug-ins de modelos LLM disponíveis, você pode usar o seguinte comando:

llm models

Isso deve fornecer uma lista dos modelos atualmente instalados.

OpenAI Chat: gpt-3.5-turbo (aliases: 3.5, chatgpt)
OpenAI Chat: gpt-3.5-turbo-16k (aliases: chatgpt-16k, 3.5-16k)
OpenAI Chat: gpt-4 (aliases: 4, gpt4)
OpenAI Chat: gpt-4-32k (aliases: 4-32k)
OpenAI Chat: gpt-4-1106-preview
OpenAI Chat: gpt-4-0125-preview
OpenAI Chat: gpt-4-turbo-2024-04-09
OpenAI Chat: gpt-4-turbo (aliases: gpt-4-turbo-preview, 4-turbo, 4t)
OpenAI Chat: gpt-4o (aliases: 4o)
OpenAI Chat: gpt-4o-mini (aliases: 4o-mini)
OpenAI Chat: o1-preview
OpenAI Chat: o1-mini
OpenAI Completion: gpt-3.5-turbo-instruct (aliases: 3.5-instruct, chatgpt-instruct)
Anthropic Messages: claude-3-opus-20240229 (aliases: claude-3-opus)
Anthropic Messages: claude-3-sonnet-20240229 (aliases: claude-3-sonnet)
Anthropic Messages: claude-3-haiku-20240307 (aliases: claude-3-haiku)
Anthropic Messages: claude-3-5-sonnet-20240620 (aliases: claude-3.5-sonnet)

Você pode usar o comando llm install (um wrapper fino em torno da instalação do pip) para instalar outros plug-ins.

Execute um prompt da CLI

Primeiro, mudaremos do ChatGPT 3.5 (o padrão) para o GPT-4o. Você pode começar a interagir com ele consultando diretamente na linha de comando. Por exemplo, faça ao modelo uma pergunta como esta:

llm -m gpt-4o "What is DigitalOcean GPU Droplet?"

DigitalOcean GPU Droplets are specialized cloud-based virtual machines designed to handle high-performance computing tasks that require GPU acceleration. These Droplets are equipped with powerful graphics processing units (GPUs) that excel at parallel processing tasks, making them ideal for applications such as machine learning, data analysis, scientific computing, and rendering tasks that require significant computational power.

With GPU Droplets, users can leverage the processing capability of GPUs to speed up tasks that would otherwise take a long time on standard CPU-based instances. DigitalOcean provides these GPU instances with various configurations, allowing users to select the number of GPUs and the specific type of GPU that suits their workload requirements.

The key features and benefits of DigitalOcean GPU Droplets include:

1. **High Performance**: Access to powerful GPUs which are optimized for intensive computational tasks.

2. **Flexible Pricing**: Pay-as-you-go pricing model allows users to scale resources up or down based on demand.

3. **Scalability**: Easily scale GPU-powered compute resources according to the needs of your application.

4. **Integration and Ease of Use**: Easy integration with other DigitalOcean products and services, providing a unified cloud infrastructure handling both compute and storage needs.

5. **Developer-Friendly**: DigitalOcean's intuitive dashboard and developer-friendly infrastructure make it simpler for developers to deploy and manage GPU-intensive applications.

Você também pode enviar um prompt para entrada padrão, por exemplo. Se você enviar texto para entrada padrão e fornecer argumentos, o prompt resultante consistirá no conteúdo canalizado seguido pelos argumentos.

Por exemplo, você pode canalizar o comando llm para solicitar que ele explique um script Python ou um trecho de código em um arquivo.

cat factorial.py | llm "Explain this code and find any bugs"

The code provided is a Python implementation of a recursive function to calculate the factorial of a non-negative integer. Here's a breakdown of how the code works along with potential issues:

### Code Explanation:

1. **Function Definition**:
   - `def factorial(n):` defines a function named `factorial` that takes one argument `n`.

2. **Base Case**:
   - The first `if` statement `if n == 0 or n == 1:` checks whether `n` is either 0 or 1. The factorial of both 0 and 1 is 1, so if this condition is true, the function returns 1.

3. **Recursive Case**:
   - The `else:` clause is executed if `n` is greater than 1. The function calls itself recursively with the argument `n - 1` and multiplies the result by `n`. This recursive calling continues until it reaches the base case.

4. **Example Usage**:
   - The code asks the user to enter a number, converts that input into an integer using `int()`, and then prints the factorial of the given number by calling the `factorial` function.

### Bug and Issues:

1. **Input Validation**:
   - The code does not handle invalid inputs, such as negative numbers or non-integer values. Factorial is defined only for non-negative integers. If the user enters a negative integer or a non-integer (such as a string), the program will either return a stack overflow error (for negative numbers leading to infinite recursion) or crash with a `ValueError` for non-integer inputs.
   
   To fix this, you could add input validation to ensure `n` is a non-negative integer:
   while True:
       try:
           number = int(input("Enter a non-negative integer: "))
           if number < 0:
               print("Please enter a non-negative integer.")
           else:
               break
       except ValueError:
           print("Invalid input. Please enter a valid integer.")

Por padrão, a ferramenta iniciará uma nova conversa cada vez que você a executar. Mas você pode optar por continuar a conversa anterior passando a opção -c/--continue:

llm "Give me more ways to optimize the code" -c

Certainly! There are several ways to optimize the code for calculating the factorial. Here are some approaches, each with its own advantages:

### 1. Iterative Approach

The iterative approach is generally more efficient in terms of memory usage compared to the recursive approach:


def factorial(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

### 2. Memoization

Using memoization can help store previously computed factorials to reduce redundant calculations. This is particularly useful if you're computing factorials of multiple numbers:


memo = {0: 1, 1: 1}  # Base case

def factorial(n):
    if n in memo:
        return memo[n]
    else:
        memo[n] = n * factorial(n - 1)
        return memo[n]


### 3. Using Python's Built-in Functions

Python has a built-in function for calculating factorials in the `math` module, which is highly optimized:

import math

number = int(input("Enter a non-negative integer: "))
print(f"The factorial of {number} is {math.factorial(number)}")

Existem vários casos de uso para usar LLM CLI em seu sistema para interagir, construir e implantar aplicativos de IA generativa. Você pode conferir mais aqui.

Conclusão

Seguindo este guia, você implantou com sucesso o modelo OpenAI GPT-4o usando o LLM CLI em um Droplet de GPU DigitalOcean. Agora você pode usar essa configuração para vários aplicativos que exigem modelos de linguagem de alto desempenho, como geração de conteúdo, chatbots ou processamento de linguagem natural.

Sinta-se à vontade para experimentar outros modelos suportados pela CLI do LLM ou dimensionar sua implantação executando vários modelos ou aumentando os recursos de seu GPU Droplet.