DianoGPT-Small 🚀

DianoGPT-Small é um modelo baseado na arquitetura T5 (Text-to-Text Transfer Transformer), otimizado para geração de conversas em linguagem natural. Ele foi fine-tuned para fornecer respostas contextuais e interações fluidas.

🌟 Características

🔹 Baseado em T5-Small
🔹 6 camadas no encoder e decoder
🔹 32K tokens no vocabulário
🔹 Mais de 60M de parâmetros
🔹 Treinado para conversação contextual

🚀 Como Usar

Carregue o modelo e gere respostas com apenas algumas linhas de código:

from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

# Carregando o modelo e o tokenizer
tokenizer = AutoTokenizer.from_pretrained("DianoAI/Diano-Small")
model = AutoModelForSeq2SeqLM.from_pretrained("DianoAI/Diano-Small")

# Exemplo de geração de resposta
def chat(input_text):
    input_ids = tokenizer.encode(input_text, return_tensors="pt")
    output_ids = model.generate(input_ids, max_length=50, num_beams=5, early_stopping=True)
    return tokenizer.decode(output_ids[0], skip_special_tokens=True)

print(chat("Olá, como você está?"))

🧠 Arquitetura

O modelo segue a estrutura do T5 e possui as seguintes configurações:

Dimensão do Modelo: 512
Cabeças de Atenção: 8
Camadas: 6 no encoder e 6 no decoder
Dropout: 0.1
Tokens Especiais: <pad>, </s>, <unk> e <extra_id_X>

📊 Treinamento

Abaixo está um gráfico da perda (loss) durante o treinamento:

⚠️ Limitações

🔸 O modelo aceita no máximo 512 tokens de entrada.
🔸 Pode gerar respostas imprecisas em contextos muito complexos.
🔸 Ainda não é otimizado para múltiplos idiomas além do português.

🎯 Contribuições

Contribuições são bem-vindas! Sinta-se à vontade para abrir issues ou pull requests com sugestões e melhorias. 🚀

🐟 Licença

Este modelo é licenciado sob a MIT License. Consulte o arquivo LICENSE para mais detalhes.

🤗 Inference API

Este modelo está disponível através da Inference API do Hugging Face. Você pode usá-lo diretamente:

import requests

API_URL = "https://api-inference.huggingface.co/models/DianoAI/Diano-Small"
headers = {"Authorization": "Bearer YOUR_API_KEY"}

def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

output = query({
    "inputs": "Olá, como você está?",
    "parameters": {"max_length": 50}
})

🚀 Hugging Face Spaces

Este modelo pode ser facilmente integrado com Hugging Face Spaces. Aqui está um exemplo básico de código para criar uma aplicação Gradio:

import gradio as gr
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

# Carrega o modelo
tokenizer = AutoTokenizer.from_pretrained("DianoAI/Diano-Small")
model = AutoModelForSeq2SeqLM.from_pretrained("DianoAI/Diano-Small")

# Função para gerar resposta
def generate_response(message, history):
    input_ids = tokenizer.encode(message, return_tensors="pt")
    output = model.generate(
        input_ids,
        max_length=100,
        num_beams=5,
        temperature=0.7,
        early_stopping=True
    )
    response = tokenizer.decode(output[0], skip_special_tokens=True)
    return response

# Interface Gradio
with gr.Blocks() as demo:
    gr.Markdown("# 🤖 DianoAI Chat")
    chatbot = gr.Chatbot()
    msg = gr.Textbox(placeholder="Digite sua mensagem aqui...")
    clear = gr.Button("Limpar Conversa")
    
    msg.submit(generate_response, [msg, chatbot], [msg, chatbot])
    clear.click(lambda: None, None, chatbot, queue=False)

demo.launch()

Para usar o modelo em um Space, inclua as seguintes dependências no seu requirements.txt:

transformers
torch
gradio

🔧 Arquivos para Spaces

Se você criar um Space para este modelo, aqui está um exemplo de arquivo app.py que você pode usar:

import gradio as gr
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
import torch

# Definir configurações do modelo
MODEL_NAME = "DianoAI/Diano-Small"
MAX_LENGTH = 100
TEMPERATURE = 0.7
NUM_BEAMS = 5

# Carregar modelo e tokenizer
print(f"Carregando modelo {MODEL_NAME}...")
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
print(f"Modelo carregado com sucesso! Utilizando: {device}")

# Função para gerar resposta
def predict(message, history):
    input_ids = tokenizer.encode(message, return_tensors="pt").to(device)
    output = model.generate(
        input_ids,
        max_length=MAX_LENGTH,
        num_beams=NUM_BEAMS,
        temperature=TEMPERATURE,
        early_stopping=True
    )
    response = tokenizer.decode(output[0], skip_special_tokens=True)
    return response

# Interface Gradio
with gr.Blocks(css="footer {visibility: hidden}") as demo:
    gr.Markdown("# 🤖 DianoAI Chat")
    gr.Markdown("Converse com o assistente virtual DianoAI, baseado em português brasileiro.")
    
    chatbot = gr.Chatbot(height=400)
    msg = gr.Textbox(placeholder="Digite sua mensagem aqui...", lines=2)
    clear = gr.Button("Limpar Conversa")
    
    msg.submit(predict, [msg, chatbot], [msg, chatbot])
    clear.click(lambda: None, None, chatbot, queue=False)
    
    gr.Markdown("### Exemplos de perguntas:")
    examples = gr.Examples(
        examples=[
            "Olá, como você está?",
            "Qual é o seu propósito?",
            "Me conte algo interessante sobre o Brasil.",
            "Como posso começar a aprender programação?",
        ],
        inputs=msg
    )
    
    gr.Markdown("## Sobre o Modelo")
    gr.Markdown("DianoAI/Diano-Small é um modelo conversacional em português brasileiro baseado na arquitetura T5.")

demo.launch()

Além disso, você vai precisar de um arquivo requirements.txt:

transformers>=4.30.0
torch>=2.0.0
gradio>=3.40.0

DianoAI
/

Diano-Small