---
language:
- pt
license: mit
base_model:
- rhaymison/t5-portuguese-small-summarization
tags:
- text-generation
- conversational
- portuguese
- t5
- transformers
- space-ready
- space-compatible
datasets:
- conversational_pt
library_name: transformers
pipeline_tag: text2text-generation
widget:
  - text: "Olá, como você está?"
  - text: "Qual é o seu propósito?"
  - text: "Me conte algo interessante sobre o Brasil."
inference: true
---
# DianoGPT-Small 🚀
![DianoGPT Banner](logobanner.png)
**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:

```python
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:
![Loss Training](training_loss.png)

## ⚠️ 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:

```python
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:

```python
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:

```python
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
```