dev-IA Related

Para criar um projeto em Docker que possibilite rodar localmente, executar consultas e adicionar dados, vamos seguir os seguintes passos:

Passos do Projeto:

Criação de um Dockerfile: Para configurar o ambiente com todas as dependências necessárias (Python, bibliotecas de aprendizado de máquina, etc.).
Configuração de um script Python para treinamento e consultas.
Configuração de um banco de dados (SQLite, PostgreSQL, etc.) para armazenamento de dados.
Criação de um README.md com as instruções de como usar o projeto.
Gerar um arquivo .zip com todos os arquivos necessários para você executar localmente.

Vou dividir o processo em partes:

1. Dockerfile

Este é o arquivo que vai configurar o ambiente de contêiner do Docker com todas as dependências necessárias para rodar o modelo de linguagem.

# Usando uma imagem base do Python
FROM python:3.9-slim

# Setando o diretório de trabalho
WORKDIR /app

# Instalando as dependências do sistema
RUN apt-get update && apt-get install -y \
    build-essential \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# Instalando as dependências do Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiando o código do projeto
COPY . /app

# Expondo a porta do Flask (se for usar uma API web)
EXPOSE 5000

# Comando para rodar o servidor ou o script de inferência
CMD ["python", "app.py"]

2. `requirements.txt`

Este arquivo contém as dependências do Python necessárias para o funcionamento do modelo, como as bibliotecas do Hugging Face para Transformers e Flask para uma API, caso queira interagir com o modelo via HTTP.

transformers==4.27.0
torch==1.11.0
flask==2.1.2
psycopg2==2.9.3  # Para conectar com banco de dados PostgreSQL (caso queira usar)

3. Script Python: `app.py`

Aqui vai um exemplo básico de como configurar um serviço com Flask para fazer consultas ao modelo treinado.

from flask import Flask, request, jsonify
from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Inicializando o Flask
app = Flask(__name__)

# Carregar o modelo e o tokenizer
model_name = "gpt2"
model = GPT2LMHeadModel.from_pretrained(model_name)
tokenizer = GPT2Tokenizer.from_pretrained(model_name)

# Rota para consulta
@app.route("/generate", methods=["POST"])
def generate_text():
    input_data = request.json.get("input", "")

    # Tokenizando a entrada
    inputs = tokenizer(input_data, return_tensors="pt")

    # Gerando resposta
    outputs = model.generate(inputs["input_ids"], max_length=50)

    # Decodificando a resposta
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)

    return jsonify({"generated_text": generated_text})

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=5000)

4. Banco de Dados

Vamos configurar um banco de dados PostgreSQL básico para armazenar os dados. Se quiser usar outro banco (como SQLite), basta substituir a string de conexão e a configuração no Python.

Aqui está um exemplo de como adicionar dados ao banco de dados via script Python:

import psycopg2
from psycopg2 import sql

# Configuração da conexão ao banco de dados
conn = psycopg2.connect(
    dbname="db_name",
    user="db_user",
    password="db_password",
    host="db_host",
    port="5432"
)
cursor = conn.cursor()

# Exemplo de inserção de dados
cursor.execute(
    sql.SQL("INSERT INTO text_data (content) VALUES (%s)"),
    ["Texto de exemplo"]
)

conn.commit()
cursor.close()
conn.close()

5. Criar `README.md`

O README.md vai conter instruções claras de como rodar o projeto.

# Projeto LLM Local

Este é um projeto para rodar um modelo de linguagem (LLM) localmente usando Docker. O modelo é treinado com a arquitetura GPT-2 da Hugging Face. A aplicação oferece uma API para consultas e permite adicionar dados ao banco de dados.

## Requisitos

Antes de executar o projeto, é necessário ter o Docker instalado em sua máquina.

## Instruções para uso

1. **Clone o repositório**:
    ```
    git clone <URL_do_repositório>
    cd nome_do_repositório
    ```

2. **Construa a imagem Docker**:
    ```
    docker build -t llm-local .
    ```

3. **Execute o container**:
    ```
    docker run -p 5000:5000 llm-local
    ```

4. **Consultar o modelo**:
    Para gerar texto, faça uma requisição POST para `http://localhost:5000/generate` com o seguinte corpo JSON:
    ```json
    {
        "input": "Exemplo de entrada para o modelo"
    }
    ```

5. **Adicionar dados ao banco de dados**:
    O banco de dados PostgreSQL pode ser acessado com o seguinte comando:
    ```
    docker exec -it <nome_do_container> psql -U <usuario> -d <nome_do_banco>
    ```

    Para adicionar dados ao banco, use o script Python fornecido em `add_data.py`.

## Tecnologias utilizadas

- Docker
- Python
- Flask
- Hugging Face Transformers
- PostgreSQL

6. Gerar o ZIP

Agora, vamos compactar o projeto em um arquivo .zip.

Estrutura de Diretórios:

/meu_projeto_llm
|-- Dockerfile
|-- requirements.txt
|-- app.py
|-- add_data.py
|-- README.md

Após criar todos os arquivos e organizá-los, você pode usar um comando de terminal para compactar o diretório:

zip -r meu_projeto_llm.zip meu_projeto_llm/

7. Enviar o ZIP para Download

Você pode facilmente gerar o arquivo ZIP a partir da estrutura acima.

Quando você tiver o projeto em mãos, basta seguir as instruções do README.md para executar localmente.

tiagofrancafernandes/LLM Local.md