Neste artigo, você aprenderá como usar modelos de linguagem hospedados localmente por meio do Ollama para realizar tarefas de classificação de texto, tudo isso sem gastar um centavo em chamadas de API.
Os tópicos que cobriremos incluem:
- Como instalar o Ollama e extrair modelos de código aberto como Llama 3, Mistral e Gemma para rodar localmente em sua máquina.
- Como configurar a biblioteca Scikit-LLM para rotear solicitações para um endpoint native do Ollama em vez de uma API de nuvem paga.
- Como construir um classificador de texto zero-shot usando um modelo de linguagem native grande e scikit-LLM em um fluxo de trabalho acquainted no estilo scikit-learn.

Usando Scikit-LLM com LLMs de código aberto
Introdução
Este artigo irá ensiná-lo a realizar uma tarefa de linguagem, como classificação de texto, integrando grandes modelos de linguagem (LLMs) de tamanho gerenciável hospedados localmente, como Mistral, Gemma e Llama 3: tudo de graça, graças a Ollama — um repositório gratuito para LLMs locais — e o Scikit-LLM Biblioteca Python.
Pré-requisito: Instalando o Ollama
Recomenda-se usar um IDE para executar este tutorial, pois precisaremos interagir com sua versão do Ollama instalada localmente a partir daí. Novo em Ollama? Então eu recomendo que você verifique este artigo sair primeiro. No entanto, aqui está um resumo do que fazer no terminal de linha de comando native para baixar um LLM native após a instalação Ollama no seu computador.
# Pulling Llama 3 (um dos modelos para obtain mais populares de Ollama) ollama run llama3 # Ou, alternativamente, tente puxar Mistral ollama run mistral # Ou, se você se sentir exigente hoje, basta puxar Gemma ollama run gemma do Google
# Pulling Llama 3 (um dos modelos para obtain mais populares de Ollama) ollama correr lhama3 # Ou alternativamente, tente puxar o Mistral ollama correr mistral # Ou, se você se sentir exigente hoje, basta puxar o Gemma do Google ollama correr gema |
Depois de ver a janela de interação do modelo no terminal, você pode digitar “/bye” para mantê-lo funcionando em segundo plano, aguardando chamadas de API. Enquanto isso, em um projeto recém-criado em seu IDE Python, você precisará ter as seguintes bibliotecas instaladas:
pip instalar scikit-learn pandas scikit-llm
pip instalar scikit–aprender pandas scikit–llm |
Se você encontrar um erro “Módulo não encontrado” ao executar o código Python, tente instalar as dependências acima uma por uma.
OK! É hora de preencher nosso arquivo de código Python (nomeie-o como desejar!), passo a passo. Primeiro, claro, vêm as importações. Uma delas é a aula ZeroShotGPTClassifier. Semelhante ao scikit-learn clássico, esta é uma aula dedicada ao treinamento e ao uso de um modelo para classificação zero-shot: concretamente, um LLM da Ollama.
importar pandas como pd de sklearn.model_selection importar train_test_split de skllm.config importar SKLLMConfig de skllm.fashions.gpt.classification.zero_shot importar ZeroShotGPTClassifier
importar pandas como PD de aprender.seleção_modelo importar train_test_split de skllm.configuração importar SKLLMConfig de skllm.modelos.gpt.classificação.tiro_zero importar ZeroShotGPTClassificador |
A seguir, precisamos aplicar algumas configurações específicas para podermos nos comunicar com o Ollama.
# Use isto para dizer ao Scikit-LLM para rotear solicitações de nuvem para sua porta Ollama native padrão SKLLMConfig.set_gpt_url(“http://localhost:11434/v1”) # O Scikit-LLM precisa, por padrão, de uma chave para passar nas verificações de validação interna. # Mas como Ollama é native e gratuito, essa string será ignorada na prática. SKLLMConfig.set_openai_key(“local-ollama-is-free”)
# Use isto para dizer ao Scikit-LLM para rotear solicitações de nuvem para sua porta Ollama native padrão SKLLMConfig.set_gpt_url(“http://localhost:11434/v1”) # O Scikit-LLM precisa, por padrão, de uma chave para passar nas verificações de validação interna. # Mas como Ollama é native e gratuito, essa string será ignorada na prática. SKLLMConfig.set_openai_key(“local-ollama-é-livre”) |
Depois disso, criamos um pequeno conjunto de dados e o preparamos para classificação. Como não avaliaremos o desempenho de classificação do modelo neste tutorial — nosso objetivo principal é aprender como usar o Scikit-LLM localmente com modelos de código aberto como aqueles disponíveis através do Ollama — não precisamos de um grande número de exemplos de dados.
information = { “evaluation”: ( “A nova atualização do macOS é fantástica e funciona perfeitamente.”, “Minha bateria está descarregando incrivelmente rápido após o patch.”, “Preciso de ajuda para redefinir a senha da minha conta.”, “A tela neste monitor é incrivelmente nítida.”, “O suporte ao cliente desligou na minha cara, muito decepcionante.” ), “class”: ( “Suggestions positivo”, “Problema técnico”, “Solicitação de suporte”, “Suggestions positivo”, “Suggestions negativo” ) } df = pd.DataFrame(information) X = df(“evaluation”) y = df(“class”) # Dividindo dados em conjuntos de treinamento/teste X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0,4, random_state=42)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | dados = { “análise”: ( “A nova atualização do macOS é fantástica e funciona perfeitamente.”, “Minha bateria está descarregando incrivelmente rápido após o patch.”, “Preciso de ajuda para redefinir a senha da minha conta.”, “A exibição neste monitor é incrivelmente nítida.”, “O suporte ao cliente desligou na minha cara, muito decepcionante.” ), “categoria”: ( “Suggestions Positivo”, “Questão Técnica”, “Solicitação de suporte”, “Suggestions Positivo”, “Suggestions Negativo” ) } df = PD.Quadro de dados(dados) X = df(“análise”) sim = df(“categoria”) # Dividindo dados em conjuntos de treinamento/teste X_trem, X_teste, y_train, y_teste = train_test_split(X, sim, tamanho_teste=0,4, estado_aleatório=42) |
O conjunto de dados contém avaliações de usuários e suas categorias correspondentes, por exemplo, tipos de consultas ou comentários de clientes. Também fizemos uma divisão de treinamento/teste como de costume com modelagem de aprendizado de máquina.
Na próxima parte do código, adicionamos as instruções necessárias para inicializar e executar nosso classificador, que será em sua essência uma instância de execução adaptada à tarefa de um de nossos modelos Ollama instalados, como o Llama 3:
print(“Inicializando ZeroShotGPTClassifier com Llama native 3…”) # Usando o prefixo ‘custom_url::’ para dizer ao sistema para usar seu endpoint “set_gpt_url” (veja acima) clf = ZeroShotGPTClassifier(mannequin=”custom_url::llama3″) # Ajustando o modelo clf.match(X_train, y_train) print(“Enviando dados para Ollama para native inferência…n”) previsões = clf.predict(X_test)
imprimir(“Inicializando ZeroShotGPTClassifier com Llama 3 native…”) # Usando o prefixo ‘custom_url::’ para informar ao sistema para usar seu endpoint “set_gpt_url” (veja acima) clf = ZeroShotGPTClassificador(modelo=“custom_url::llama3”) # Ajustando o modelo clf.ajustar(X_trem, y_train) imprimir(“Enviando dados para Ollama para inferência native…n”) previsões = clf.prever(X_teste) |
Para finalizar, imprimimos algumas saídas que consistem em alguns resultados de inferência de modelo (previsões de classificação) nos dois exemplos contidos no conjunto de teste. Este é um conjunto de dados muito pequeno, mas o objetivo aqui é mostrar como conseguimos vincular o Scikit-LLM a um modelo Ollama native e gratuito para usar um LLM com elegância para uma tarefa específica sem nenhum custo!
para revisão, previsão em zip(X_test, previsões): print(f”Evaluate Textual content: ‘{evaluation}'”) print(f”Predicted Tag: {prediction}”) print(“-” * 50)
para análise, previsão em zip(X_teste, previsões): imprimir(f“Texto de revisão: ‘{evaluation}'”) imprimir(f“Tag prevista: {predição}”) imprimir(“-“ * 50) |
O resultado (pode variar dependendo dos exemplos de teste):
Enviando dados para Ollama para inferência native… 100%|███████████████████████████ ████████████████████████████████| 2/2 (00:12<00:00, 6,36s/it) Texto de revisão: 'Minha bateria está descarregando incrivelmente rápido após o patch.' Tag prevista: Solicitação de suporte -------------------------------------------------- Texto de revisão: 'O suporte ao cliente desligou na minha cara, muito decepcionante.' Tag prevista: Solicitação de suporte --------------------------------------------------
Enviando dados para Ollama para native inferência... 100%|█████████████████████████████ ██████████████████████████████| 2/2 (00:12<00:00, 6,36s/isto) Análise Texto: ‘Minha bateria está descarregando incrivelmente rápido após o patch.’ Previsto Marcação: Apoiar Solicitar ————————————————————————— Análise Texto: ‘O suporte ao cliente desligou na minha cara, muito decepcionante.’ Previsto Marcação: Apoiar Solicitar ————————————————————————— |
Alternativamente, você pode executar seu script Python em seu terminal. Por exemplo, se você nomeou local_classification.pyexecute este comando:
python local_classificação.py
píton classificação_local.py |
De qualquer forma, se você seguiu todas as etapas, deverá fazê-lo funcionar. Bom trabalho!
Concluindo
Este artigo ilustrou como trocar modelos gratuitos executados localmente servidos por meio do Ollama, como Llama, Mistral ou Gemma — tudo de graça e em algumas etapas fáceis — graças à biblioteca Scikit-LLM do Python, que permite o uso de LLMs de ponta em um fluxo de trabalho clássico acquainted de aprendizado de máquina.