{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "provenance": [],
   "gpuType": "T4"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 🏛️ IVRIUS — Fine Tuning Jurídico Bilíngue\n",
    "**Modelo:** Llama-3.1-8B + QLoRA (4-bit)\n",
    "**Dataset:** STJ + TJMG + Pares BR↔US + CIJ\n",
    "**Tempo estimado:** 1-2h no T4 Colab\n",
    "\n",
    "### ✅ Checklist antes de rodar:\n",
    "- [ ] Runtime → Change runtime type → **T4 GPU**\n",
    "- [ ] Conectado ao Colab\n",
    "- [ ] Token HuggingFace disponível"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 1: Instalar dependências ──────────────────────────────\n",
    "!pip install -q \"unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git\"\n",
    "!pip install -q --no-deps xformers trl peft accelerate bitsandbytes\n",
    "!pip install -q datasets huggingface_hub\n",
    "print('✅ Dependências instaladas!')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 2: Configuração ────────────────────────────────────────\n",
    "HF_TOKEN    = 'SEU_HF_TOKEN_AQUI'\n",
    "HF_REPO_OUT = 'MMR408/ivrius-llama-juridico-v1'  # onde salvar o modelo\n",
    "MODEL_BASE  = 'unsloth/llama-3.1-8b-bnb-4bit'\n",
    "\n",
    "import os\n",
    "os.environ['HF_TOKEN'] = HF_TOKEN\n",
    "\n",
    "from huggingface_hub import login\n",
    "login(token=HF_TOKEN)\n",
    "print('✅ HuggingFace autenticado!')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 3: Carregar modelo base ───────────────────────────────\n",
    "from unsloth import FastLanguageModel\n",
    "import torch\n",
    "\n",
    "max_seq_length = 2048\n",
    "dtype = None\n",
    "load_in_4bit = True\n",
    "\n",
    "model, tokenizer = FastLanguageModel.from_pretrained(\n",
    "    model_name=MODEL_BASE,\n",
    "    max_seq_length=max_seq_length,\n",
    "    dtype=dtype,\n",
    "    load_in_4bit=load_in_4bit,\n",
    "    token=HF_TOKEN,\n",
    ")\n",
    "print('✅ Modelo base carregado!')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 4: Configurar LoRA ─────────────────────────────────────\n",
    "model = FastLanguageModel.get_peft_model(\n",
    "    model,\n",
    "    r=16,\n",
    "    target_modules=['q_proj','k_proj','v_proj','o_proj',\n",
    "                    'gate_proj','up_proj','down_proj'],\n",
    "    lora_alpha=16,\n",
    "    lora_dropout=0,\n",
    "    bias='none',\n",
    "    use_gradient_checkpointing='unsloth',\n",
    "    random_state=42,\n",
    ")\n",
    "print('✅ LoRA configurado!')\n",
    "model.print_trainable_parameters()"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 5: Preparar datasets ───────────────────────────────────\n",
    "from datasets import load_dataset, Dataset, concatenate_datasets\n",
    "import json\n",
    "\n",
    "ALPACA_PROMPT = \"\"\"Abaixo está uma instrução jurídica. Responda de forma precisa e fundamentada.\n",
    "\n",
    "### Instrução:\n",
    "{instruction}\n",
    "\n",
    "### Resposta:\n",
    "{response}\"\"\"\n",
    "\n",
    "EOS = tokenizer.eos_token\n",
    "\n",
    "def format_alpaca(examples):\n",
    "    texts = []\n",
    "    for inst, resp in zip(examples['instruction'], examples['response']):\n",
    "        texts.append(ALPACA_PROMPT.format(instruction=inst, response=resp) + EOS)\n",
    "    return {'text': texts}\n",
    "\n",
    "# ── Dataset 1: STJ ementas (resumo) ──────────────────────────────\n",
    "print('📥 Carregando STJ...')\n",
    "stj_raw = load_dataset('celsowm/jurisprudencias_stj', split='train[:2000]', token=HF_TOKEN)\n",
    "\n",
    "def stj_to_alpaca(row):\n",
    "    ementa = str(row.get('ementa_texto') or '').strip()[:500]\n",
    "    acordao = str(row.get('acordao') or '').strip()[:1000]\n",
    "    if not ementa or len(ementa) < 50:\n",
    "        return None\n",
    "    return {\n",
    "        'instruction': f'Resuma a seguinte decisão jurídica do STJ ({row.get(\"identificacao\",\"\")}):\\n{acordao[:600] if acordao else ementa}',\n",
    "        'response': ementa\n",
    "    }\n",
    "\n",
    "stj_items = [stj_to_alpaca(r) for r in stj_raw if stj_to_alpaca(r)]\n",
    "ds_stj = Dataset.from_list(stj_items)\n",
    "print(f'✅ STJ: {len(ds_stj)} exemplos')\n",
    "\n",
    "# ── Dataset 2: TJMG ementas ───────────────────────────────────────\n",
    "print('📥 Carregando TJMG...')\n",
    "tjmg_raw = load_dataset('celsowm/jurisprudencias_tjmg', split='train[:2000]', token=HF_TOKEN)\n",
    "\n",
    "def tjmg_to_alpaca(row):\n",
    "    ementa = str(row.get('ementa') or '').strip()[:500]\n",
    "    if not ementa or len(ementa) < 50:\n",
    "        return None\n",
    "    return {\n",
    "        'instruction': f'Resuma a seguinte decisão jurídica do TJMG ({row.get(\"numero_processo\",\"\")}):\\n{ementa[:300]}',\n",
    "        'response': ementa\n",
    "    }\n",
    "\n",
    "tjmg_items = [tjmg_to_alpaca(r) for r in tjmg_raw if tjmg_to_alpaca(r)]\n",
    "ds_tjmg = Dataset.from_list(tjmg_items)\n",
    "print(f'✅ TJMG: {len(ds_tjmg)} exemplos')\n",
    "\n",
    "# ── Dataset 3: Pares bilíngues BR↔US (do HuggingFace) ────────────\n",
    "print('📥 Carregando pares bilíngues...')\n",
    "ds_pairs_raw = load_dataset('MMR408/proejto2', split='train', token=HF_TOKEN)\n",
    "\n",
    "# Fallback: usar pares hardcoded se não encontrar\n",
    "# (você pode subir o JSONL manualmente no Colab também)\n",
    "pairs_items = []\n",
    "for row in ds_pairs_raw:\n",
    "    prompt = str(row.get('prompt') or '')\n",
    "    response = str(row.get('response') or '')\n",
    "    if prompt and response and len(response) > 100:\n",
    "        pairs_items.append({'instruction': prompt, 'response': response})\n",
    "\n",
    "ds_pairs = Dataset.from_list(pairs_items) if pairs_items else Dataset.from_list([])\n",
    "print(f'✅ Pares BR↔US: {len(ds_pairs)} exemplos')\n",
    "\n",
    "# ── Combinar todos ────────────────────────────────────────────────\n",
    "datasets_list = [ds for ds in [ds_stj, ds_tjmg, ds_pairs] if len(ds) > 0]\n",
    "ds_combined = concatenate_datasets(datasets_list).shuffle(seed=42)\n",
    "print(f'\\n✅ Dataset combinado: {len(ds_combined)} exemplos totais')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 6: Tokenizar ───────────────────────────────────────────\n",
    "ds_formatted = ds_combined.map(format_alpaca, batched=True,\n",
    "                                remove_columns=ds_combined.column_names)\n",
    "print(f'✅ Tokenizado: {len(ds_formatted)} exemplos')\n",
    "print(f'\\nAmostra:\\n{ds_formatted[0][\"text\"][:300]}...')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 7: Treinar ─────────────────────────────────────────────\n",
    "from trl import SFTTrainer\n",
    "from transformers import TrainingArguments\n",
    "from unsloth import is_bfloat16_supported\n",
    "\n",
    "trainer = SFTTrainer(\n",
    "    model=model,\n",
    "    tokenizer=tokenizer,\n",
    "    train_dataset=ds_formatted,\n",
    "    dataset_text_field='text',\n",
    "    max_seq_length=max_seq_length,\n",
    "    dataset_num_proc=2,\n",
    "    packing=False,\n",
    "    args=TrainingArguments(\n",
    "        per_device_train_batch_size=2,\n",
    "        gradient_accumulation_steps=4,\n",
    "        warmup_steps=10,\n",
    "        max_steps=120,          # ~1.5h no T4 — aumente para 300 se quiser mais qualidade\n",
    "        learning_rate=2e-4,\n",
    "        fp16=not is_bfloat16_supported(),\n",
    "        bf16=is_bfloat16_supported(),\n",
    "        logging_steps=10,\n",
    "        optim='adamw_8bit',\n",
    "        weight_decay=0.01,\n",
    "        lr_scheduler_type='linear',\n",
    "        seed=42,\n",
    "        output_dir='ivrius_output',\n",
    "        report_to='none',\n",
    "    ),\n",
    ")\n",
    "\n",
    "print('🚀 Iniciando treino...')\n",
    "trainer_stats = trainer.train()\n",
    "print(f'\\n✅ Treino concluído!')\n",
    "print(f'   Loss final: {trainer_stats.training_loss:.4f}')\n",
    "print(f'   Tempo: {trainer_stats.metrics[\"train_runtime\"]/60:.1f} minutos')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 8: Testar o modelo ─────────────────────────────────────\n",
    "FastLanguageModel.for_inference(model)\n",
    "\n",
    "testes = [\n",
    "    'O que é dano moral no direito brasileiro? Compare com o conceito americano.',\n",
    "    'Explique o habeas corpus no Brasil e seu equivalente nos EUA.',\n",
    "    'Qual a diferença entre prescrição e decadência no direito civil brasileiro?',\n",
    "]\n",
    "\n",
    "for pergunta in testes:\n",
    "    prompt = ALPACA_PROMPT.format(instruction=pergunta, response='') \n",
    "    inputs = tokenizer([prompt], return_tensors='pt').to('cuda')\n",
    "    outputs = model.generate(**inputs, max_new_tokens=300,\n",
    "                              temperature=0.3, do_sample=True,\n",
    "                              pad_token_id=tokenizer.eos_token_id)\n",
    "    resposta = tokenizer.batch_decode(outputs)[0]\n",
    "    resposta_limpa = resposta.split('### Resposta:')[-1].replace(tokenizer.eos_token,'').strip()\n",
    "    print(f'\\n❓ {pergunta}')\n",
    "    print(f'💬 {resposta_limpa[:400]}')\n",
    "    print('─'*60)"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 9: Salvar LoRA no HuggingFace ─────────────────────────\n",
    "print(f'💾 Salvando LoRA em {HF_REPO_OUT}...')\n",
    "model.save_pretrained('ivrius_lora')\n",
    "tokenizer.save_pretrained('ivrius_lora')\n",
    "\n",
    "model.push_to_hub(HF_REPO_OUT, token=HF_TOKEN)\n",
    "tokenizer.push_to_hub(HF_REPO_OUT, token=HF_TOKEN)\n",
    "print(f'\\n✅ Modelo salvo em: https://huggingface.co/{HF_REPO_OUT}')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# ── Célula 10 (opcional): Merge + GGUF para LM Studio ────────────\n",
    "# Descomente se quiser rodar localmente no LM Studio\n",
    "\n",
    "# print('🔧 Fazendo merge do modelo...')\n",
    "# model.save_pretrained_merged('ivrius_merged', tokenizer, save_method='merged_16bit')\n",
    "# model.push_to_hub_merged(HF_REPO_OUT + '-merged', tokenizer,\n",
    "#                          save_method='merged_16bit', token=HF_TOKEN)\n",
    "\n",
    "# # Converter para GGUF (para LM Studio / Ollama)\n",
    "# model.save_pretrained_gguf('ivrius_gguf', tokenizer, quantization_method='q4_k_m')\n",
    "# model.push_to_hub_gguf(HF_REPO_OUT + '-gguf', tokenizer,\n",
    "#                        quantization_method='q4_k_m', token=HF_TOKEN)\n",
    "# print('✅ GGUF salvo!')\n",
    "\n",
    "print('Célula 10 pronta — descomente para gerar GGUF')"
   ],
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ✅ Concluído!\n",
    "\n",
    "Seu modelo IVRIUS está treinado e salvo no HuggingFace.\n",
    "\n",
    "**Próximos passos:**\n",
    "1. Descomentar célula 10 para gerar GGUF (LM Studio / Ollama)\n",
    "2. Integrar no Lambda AWS via Bedrock Custom Model\n",
    "3. Adicionar disclaimer OAB nas respostas\n",
    "4. Integrar RAG com Qdrant + voyage-law-2\n",
    "\n",
    "**Modelo salvo em:** `MMR408/ivrius-llama-juridico-v1`\n",
    "\n",
    "---\n",
    "_IVRIUS — Intelligent Virtual Research and Information System_  \n",
    "_Dra. Miriam Mesquita — OAB_"
   ]
  }
 ]
}