Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+imgs/architecture.png filter=lfs diff=lfs merge=lfs -text
+imgs/historinhas-logo.png filter=lfs diff=lfs merge=lfs -text

breno-trabalho-final.ipynb

@@ -0,0 +1,524 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e176393b",
+   "metadata": {},
+   "source": [
+    "<img src=\"IMGS/historinhas-logo.png\" alt=\"drawing\" width=\"400\"/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1fbc91d",
+   "metadata": {},
+   "source": [
+    "# Historinhas-102M\n",
+    "\n",
+    "## Visão Geral\n",
+    "\n",
+    "Inspirado no artigo [TinyStories: How Small Can Language Models Be and Still Speak Coherent English?](https://arxiv.org/abs/2305.07759), este projeto tem como objetivo a criação de um conjunto de dados e o treinamento de um modelo de linguagem do zero capaz de gerar texto coerente em português brasileiro. O foco principal está na geração de histórias infantis simples e coerentes, demonstrando que mesmo modelos extremamente pequenos para os padrões atuais podem produzir conteúdo textual de qualidade."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a12941c0",
+   "metadata": {},
+   "source": [
+    "#### Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6ecd2350",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "from tokenizers import Tokenizer\n",
+    "\n",
+    "from dataclasses import dataclass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f4c90336",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Seleciona a GPU se disponível, caso contrário, usa a CPU\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "# Configurações do modelo (102 milhões de parâmetros)\n",
+    "@dataclass\n",
+    "class ModelConfig:\n",
+    "    d_emb: int = 512\n",
+    "    vocab_size: int = 20000\n",
+    "    num_layers: int = 8\n",
+    "    num_heads: int = 8\n",
+    "    num_hidden: int = 4 * d_emb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71f512c4",
+   "metadata": {},
+   "source": [
+    "## Arquitetura do modelo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b996dfc",
+   "metadata": {},
+   "source": [
+    "## Arquitetura Inspirada no LLaMA\n",
+    "\n",
+    "Esta arquitetura segue os princípios da família de modelos **LLaMA**, com algumas modificações para melhorar o desempenho.\n",
+    "\n",
+    "### Principais Modificações\n",
+    "\n",
+    "* Substituição do **Grouped Query Attention** por **Multi-Head Attention**\n",
+    "\n",
+    "  > Prioriza desempenho, mesmo com maior custo computacional.\n",
+    "\n",
+    "* **KV-cache** não implementado\n",
+    "\n",
+    "  > Foco em simplicidade e clareza no fluxo de atenção.\n",
+    "\n",
+    "\n",
+    "### Comparação com a Arquitetura Original do Transformer\n",
+    "\n",
+    "| Característica                 | Arquitetura Atual            | Transformer Original        |\n",
+    "| ------------------------------ | ---------------------------- | --------------------------- |\n",
+    "| Estrutura                      | **Decoder-only**             | Encoder-Decoder             |\n",
+    "| Normalização                   | **RMS Norm**                 | Layer Norm                  |\n",
+    "| Ordem da Normalização          | **Antes da adição residual** | Depois da adição residual   |\n",
+    "| Função de Ativação             | **SwiGLU**                   | ReLU                        |\n",
+    "| Positional Embedding           | **Rotary Embedding**         | Absolute Positional Embedding |\n",
+    "| Weight Tying | ✅ Sim                    | ❌ Ausente (em muitos casos) |\n",
+    "\n",
+    "\n",
+    "### Diagrama da Arquitetura do Modelo\n",
+    "<img src=\"imgs/architecture.png\" alt=\"drawing\" width=\"200\"/>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c65bba83",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SwiGlu(nn.Module):\n",
+    "    def __init__(self, d_emb):\n",
+    "        super().__init__()\n",
+    "        self.ll = nn.Linear(d_emb, 2 * d_emb)\n",
+    "        self.silu = nn.SiLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.ll(x)\n",
+    "        a, b = x.chunk(2, dim=-1)\n",
+    "        return self.silu(a) * b\n",
+    "\n",
+    "\n",
+    "class FeedForward(nn.Module):\n",
+    "    def __init__(self, d_emb, num_hidden):\n",
+    "        super().__init__()\n",
+    "        self.fc1 = nn.Linear(d_emb, num_hidden)\n",
+    "        self.swiglu = SwiGlu(num_hidden)\n",
+    "        self.fc2 = nn.Linear(num_hidden, d_emb)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.fc2(self.swiglu(self.fc1(x)))\n",
+    "\n",
+    "\n",
+    "class RoPe(nn.Module):\n",
+    "    def __init__(self, head_d_emb, base=10000.0):\n",
+    "        super().__init__()\n",
+    "        inv_freq = 1 / (base ** (torch.arange(0, head_d_emb, 2).float() / head_d_emb))\n",
+    "        self.register_buffer(\"inv_freq\", inv_freq)\n",
+    "\n",
+    "    def _build_cos_sin(self, seq_length):\n",
+    "        t = torch.arange(0, seq_length, device=device).type_as(self.inv_freq)\n",
+    "        freq = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n",
+    "        freq = torch.repeat_interleave(freq, 2, dim=-1)\n",
+    "        cos, sin = freq.cos(), freq.sin()\n",
+    "        return cos, sin\n",
+    "\n",
+    "    def forward(self, q, k):\n",
+    "        seq_length = q.shape[-2]\n",
+    "        cos, sin = self._build_cos_sin(seq_length)\n",
+    "        cos = cos[None, None, :, :].to(q.dtype)\n",
+    "        sin = sin[None, None, :, :].to(q.dtype)\n",
+    "\n",
+    "        def rotate(x):\n",
+    "            x_even, x_odd = x[..., ::2], x[..., 1::2]\n",
+    "            new_x = torch.stack((-x_odd, x_even), dim=-1).flatten(-2)\n",
+    "            return new_x\n",
+    "\n",
+    "        q_rot = q * cos + rotate(q) * sin\n",
+    "        k_rot = k * cos + rotate(k) * sin\n",
+    "\n",
+    "        return q_rot, k_rot\n",
+    "\n",
+    "\n",
+    "class MultiheadAttention(nn.Module):\n",
+    "    def __init__(self, num_heads, d_emb):\n",
+    "        super().__init__()\n",
+    "        self.num_heads = num_heads\n",
+    "        self.head_dim = d_emb // num_heads\n",
+    "        self.qkv_layer = nn.Linear(d_emb, 3 * d_emb)\n",
+    "        self.rope = RoPe(self.head_dim)\n",
+    "        self.ll = nn.Linear(d_emb, d_emb)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        batch_size, seq_length, d_emb = x.shape\n",
+    "        qkv = self.qkv_layer(x)\n",
+    "        qkv = qkv.view(batch_size, seq_length, self.num_heads, 3 * self.head_dim)\n",
+    "        qkv = qkv.permute(0, 2, 1, 3)\n",
+    "        q, k, v = qkv.chunk(3, dim=-1)\n",
+    "\n",
+    "        q, k = self.rope(q, k)\n",
+    "\n",
+    "        values = F.scaled_dot_product_attention(q, k, v, is_causal=True)\n",
+    "        values = values.permute(0, 2, 1, 3)\n",
+    "        values = values.contiguous()\n",
+    "        values = values.view(batch_size, seq_length, self.num_heads * self.head_dim)\n",
+    "        out = self.ll(values)\n",
+    "        return out\n",
+    "\n",
+    "\n",
+    "class TransformerDecoderBlock(nn.Module):\n",
+    "    def __init__(self, num_heads, d_emb, num_hidden):\n",
+    "        super().__init__()\n",
+    "        self.rmsn1 = nn.RMSNorm(d_emb)\n",
+    "        self.multihead_attention = MultiheadAttention(num_heads, d_emb)\n",
+    "        self.rmsn2 = nn.RMSNorm(d_emb)\n",
+    "        self.ff = FeedForward(d_emb, num_hidden)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x + self.multihead_attention(self.rmsn1(x))\n",
+    "        x = x + self.ff(self.rmsn2(x))\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "class HistorinhasLM(nn.Module):\n",
+    "    def __init__(self, config: ModelConfig, tokenizer: Tokenizer):\n",
+    "        super().__init__()\n",
+    "        self.vocab_size = config.vocab_size\n",
+    "        self.we = nn.Embedding(config.vocab_size, config.d_emb)\n",
+    "        self.sequential = nn.Sequential(\n",
+    "            *[\n",
+    "                TransformerDecoderBlock(\n",
+    "                    config.num_heads, config.d_emb, config.num_hidden\n",
+    "                )\n",
+    "                for _ in range(config.num_layers)\n",
+    "            ]\n",
+    "        )\n",
+    "        self.rmsn = nn.RMSNorm(config.d_emb)\n",
+    "        self.fc = nn.Linear(config.d_emb, config.vocab_size, bias=False)\n",
+    "\n",
+    "        self.we.weight = self.fc.weight\n",
+    "\n",
+    "        self.criterion = nn.CrossEntropyLoss()\n",
+    "        \n",
+    "        self.tokenizer = tokenizer\n",
+    "        self.tokenizer.enable_truncation(max_length=512)\n",
+    "\n",
+    "    def forward(self, x, y=None):\n",
+    "        x = self.we(x)\n",
+    "        x = self.sequential(x)\n",
+    "        x = self.rmsn(x)\n",
+    "        logits = self.fc(x)\n",
+    "        if y != None:\n",
+    "            loss = self.criterion(logits.view(-1, self.vocab_size), y.view(-1))\n",
+    "            return logits, loss\n",
+    "\n",
+    "        return logits\n",
+    "    \n",
+    "    # Função para gerar texto a partir de um modelo treinado\n",
+    "    @torch.no_grad()\n",
+    "    def generate(self, input, temperature=0.3, max_length=500, k=10):\n",
+    "        self.eval()\n",
+    "        input = torch.tensor([self.tokenizer.encode(input).ids], dtype=torch.long).to(device)\n",
+    "        print(self.tokenizer.decode(input[0].tolist(), skip_special_tokens=False), end=\"\")\n",
+    "\n",
+    "        for i in range(max_length):\n",
+    "            logits = self(input)\n",
+    "            logits = logits[:, -1, :]\n",
+    "\n",
+    "            if temperature == 0:\n",
+    "                idx_next = torch.argmax(logits, dim=-1, keepdim=True) \n",
+    "            else:\n",
+    "                logits = logits / temperature \n",
+    "                top_k_logits, top_k_indices = torch.topk(logits, k, dim=-1) \n",
+    "                top_k_probs = F.softmax(top_k_logits, dim=-1)\n",
+    "                sampled_relative_index = torch.multinomial(top_k_probs, num_samples=1)\n",
+    "                idx_next = torch.gather(top_k_indices, dim=-1, index=sampled_relative_index) \n",
+    "\n",
+    "            input = torch.cat((input, idx_next), dim=-1)\n",
+    "\n",
+    "            generated_token_id = idx_next[0, 0].item()\n",
+    "            print(self.tokenizer.decode([generated_token_id], skip_special_tokens=False),end=\"\")\n",
+    "\n",
+    "            if generated_token_id == self.tokenizer.encode(\"<|end|>\").ids[0]:\n",
+    "                break\n",
+    "\n",
+    "        print() \n",
+    "        self.train()\n",
+    "        return input\n",
+    "    \n",
+    "    def get_num_parameters(self):\n",
+    "        return sum([x.view(-1).shape[0] for x in self.parameters()])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "919c3d61",
+   "metadata": {},
+   "source": [
+    "## 📚 Conjunto de Dados e Treinamento do Modelo\n",
+    "\n",
+    "O projeto **Historinhas-102M** utiliza um conjunto de dados com **1.255.240 histórias infantis**, totalizando **mais de 300 milhões de tokens**.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 🧠 Geração dos Dados\n",
+    "\n",
+    "As histórias foram geradas com auxílio dos seguintes modelos de linguagem:\n",
+    "\n",
+    "- **Gemini 2.0 Flash**\n",
+    "- **Gemini 2.0 Flash-exp**\n",
+    "- **Gemini 2.0 Flash-Lite**\n",
+    "- **Gemini 2.0 Flash Thinking**\n",
+    "- **Gemma 3 27B**\n",
+    "\n",
+    "> 🕒 *Todo o processo de geração foi realizado de forma gratuita e levou aproximadamente **3 semanas** para ser concluído.*\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 🏋️ Treinamento do Modelo\n",
+    "\n",
+    "- **Número de épocas:** ~5  \n",
+    "- **Duração total:** ~25 horas  \n",
+    "- **Hardware utilizado:** NVIDIA T4 GPU\n",
+    "\n",
+    "> O modelo possui **102 milhões de parâmetros** (equivalente ao tamanho do BERT base) e foi treinado para gerar histórias infantis coerentes em português.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 💻 Código de Treinamento\n",
+    "\n",
+    "Devido ao tamanho do conjunto de dados, ao tempo necessário e à complexidade do código de treinamento, o notebook **não está incluído aqui**.  \n",
+    "Você pode acessá-lo diretamente no repositório do Github:\n",
+    "\n",
+    "🔗 [Código de Treinamento – Github](https://github.com/Boakpe/Historinhas-102M)\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 📥 Download do Dataset\n",
+    "\n",
+    "O conjunto de dados completo, junto com mais informações, está disponível aqui:\n",
+    "\n",
+    "🔗 [Dataset \"Historinhas\" – Hugging Face](https://huggingface.co/datasets/Boakpe/historinhas)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1991c82a",
+   "metadata": {},
+   "source": [
+    "## ✂️ Tokenizer\n",
+    "\n",
+    "O **tokenizer** utilizado neste projeto foi treinado com a biblioteca [🤗 Hugging Face Tokenizers](https://huggingface.co/docs/tokenizers/index), utilizando o algoritmo **BPE (Byte Pair Encoding)**.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 📦 Detalhes do Tokenizer\n",
+    "\n",
+    "- **Algoritmo:** BPE (Byte Pair Encoding)  \n",
+    "- **Vocabulário:** 20.000 tokens  \n",
+    "- **Dataset utilizado:** [Historinhas Dataset](https://huggingface.co/datasets/Boakpe/historinhas)\n",
+    "\n",
+    "> ⚠️ Devido ao tamanho do conjunto de dados, o treinamento do tokenizer leva aproximadamente **20 minutos**.  \n",
+    "> Para facilitar, o tokenizer já foi previamente treinado e está disponível no arquivo:  \n",
+    "> **`tokenizer.json`**\n",
+    "\n",
+    "---\n",
+    "\n",
+    "### 🧩 Carregando o Tokenizer\n",
+    "\n",
+    "O código abaixo apenas realiza o carregamento do tokenizer já treinado:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b9be5960",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = Tokenizer.from_file(\"historinhas-102M/tokenizer.json\")\n",
+    "tokenizer.enable_padding(direction=\"right\", pad_id=0, pad_token=\"<|pad|>\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "313e835f",
+   "metadata": {},
+   "source": [
+    "## Carrega o modelo e realiza a inferência"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e3e5c0eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "102.59 milhões de parâmetros\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Carrega o modelo e move para o dispositivo correto\n",
+    "model = HistorinhasLM(ModelConfig(), tokenizer)\n",
+    "model.to(device)\n",
+    "\n",
+    "# Imprime o número total de parâmetros do modelo\n",
+    "print(round((model.get_num_parameters() / 1_000_000), 2), 'milhões de parâmetros')\n",
+    "\n",
+    "# Carrega os pesos do modelo com os pesos pré-treinados\n",
+    "model.load_state_dict(torch.load('historinhas-102M/historinhas-102M.pth'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "9a4cb122",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<|end|> Denilson era um cientista muito inteligente, mas um pouco distraído. Ele adorava inventar coisas em seu laboratório, mas às vezes, suas invenções não saíam como planejado.\n",
+      "\n",
+      "Um dia, Denilson estava trabalhando em uma fórmula para fazer as plantas crescerem mais rápido. Ele misturou vários ingredientes, mas a fórmula explodiu, sujando todo o laboratório e transformando-o em um monte de lama.\n",
+      "\n",
+      "Denilson ficou muito triste. Ele havia falhado em sua pesquisa e agora tudo estava arruinado. Ele se sentou no chão, desanimado.\n",
+      "\n",
+      "De repente, ele ouviu uma voz. \"Não desista, Denilson! Você é um cientista incrível! Use sua criatividade para resolver os problemas!\"\n",
+      "\n",
+      "Era a voz de sua amiga, a cientista Sofia. Ela tinha vindo de outro laboratório para ajudar Denilson a criar uma nova fórmula.\n",
+      "\n",
+      "Denilson pensou um pouco e decidiu seguir o conselho de Sofia. Ele começou a usar os materiais que encontrou no laboratório para criar uma nova fórmula, mais simples e eficaz.\n",
+      "\n",
+      "Ele misturou os ingredientes com cuidado, seguindo a receita antiga de Sofia. Ele misturou os ingredientes com carinho e atenção.\n",
+      "\n",
+      "Depois de algumas horas, a nova fórmula estava pronta. Era uma mistura de vinagre, vinagre e um pouco de glitter.\n",
+      "\n",
+      "Denilson ficou muito feliz com sua invenção. Ele percebeu que, mesmo com os erros, ele podia aprender com eles e criar coisas incríveis.\n",
+      "\n",
+      "Ele agradeceu a Sofia por acreditar nele e por ensiná-lo a importância da persistência. Ele aprendeu que a gratidão é uma forma de reconhecer o valor das pessoas e de valorizar o trabalho em equipe.\n",
+      "\n",
+      "Denilson continuou a inventar coisas incríveis, sempre com gratidão no coração. Ele sabia que, com a ajuda de seus amigos e a persistência, ele poderia superar qualquer desafio.<|end|>\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Exemplo de uso da função de geração\n",
+    "# Sempre use o token <|end|> para iniciar a geração\n",
+    "# Outros exemplos:\n",
+    "# <|end|>Denilson era um professor\n",
+    "# <|end|>\n",
+    "# <|end|>Era uma vez\n",
+    "# <|end|>Em uma terra\n",
+    "texto = \"<|end|>Denilson era um cientista\"\n",
+    "generated_id = model.generate(texto)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aee7e533",
+   "metadata": {},
+   "source": [
+    "## Considerações Finais\n",
+    "\n",
+    "### Desempenho e Generalização\n",
+    "\n",
+    "O modelo apresentou um desempenho muito bom, sendo capaz de gerar histórias coerentes na grande maioria dos casos testados. Um aspecto particularmente impressionante foi sua capacidade de generalização - mesmo quando apresentado a nomes de personagens que nunca apareceram no conjunto de treinamento (como \"Denilson\"), o modelo consegue gerar narrativas perfeitamente estruturadas. Além disso, todas as histórias criadas são inéditas, sem cópias de histórias existentes no conjunto de dados.\n",
+    "\n",
+    "### Tamanho do Modelo vs. Conjunto de Dados\n",
+    "\n",
+    "Apesar do modelo ser relativamente grande em comparação ao tamanho do conjunto de dados (102M de parâmetros para 300 milhões de tokens) - aproximadamente 3 parâmetros por token, bem abaixo dos 20 recomendados pela Chinchilla scaling laws - ele não apresentou sinais de overfitting. \n",
+    "\n",
+    "Além disso, a qualidade das saídas geradas foi significativamente superior quando comparada a modelos menores que seguem mais estritamente as recomendações de escala. Durante o desenvolvimento, foram treinados dois modelos adicionais com 32 milhões e 69 milhões de parâmetros, respectivamente, mas esta versão de 102M parâmetros foi a que demonstrou melhor criatividade e qualidade nas histórias geradas.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7e6c310",
+   "metadata": {},
+   "source": [
+    "## Bibliografia\n",
+    "\n",
+    "- **TinyStories: How Small Can Language Models Be and Still Speak Coherent English?**  \n",
+    "  [arXiv:2305.07759](https://arxiv.org/abs/2305.07759)\n",
+    "\n",
+    "- **GLU Variants Improve Transformer**  \n",
+    "  [arXiv:2002.05202](https://arxiv.org/abs/2002.05202)\n",
+    "\n",
+    "- **RoFormer: Enhanced Transformer with Rotary Position Embedding**  \n",
+    "  [arXiv:2104.09864](https://arxiv.org/abs/2104.09864)\n",
+    "\n",
+    "- **Language Models are Unsupervised Multitask Learners**  \n",
+    "  [OpenAI Technical Report](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf)\n",
+    "\n",
+    "- **Language Models are Few-Shot Learners**   \n",
+    "  [arXiv:2005.14165](https://arxiv.org/abs/2005.14165)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

historinhas-102M/historinhas-102M.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3434b74068a50a7be276ffff8cddad3343b578586c690fa07b5d57a7fd609e7
+size 410412348

requirements.txt

@@ -0,0 +1,3 @@
+torch
+tokenizers
+numpy