train_v14.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "BHZnXywjxGeq"
   },
   "outputs": [],
   "source": [
    "#https://pytorch.org/tutorials/beginner/transformer_tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "kY_j8RUDP5y4"
   },
   "outputs": [],
   "source": [
    "from torch import nn, Tensor\n",
    "import torch.nn.functional as F\n",
    "import torch\n",
    "import math\n",
    "from torch.autograd.variable import Variable\n",
    "import typing\n",
    "import random\n",
    "import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "y4lRdOSZNpe2"
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ph2WO5JpKukk",
    "outputId": "ab00d895-307a-4ade-e705-1c6dd8ae6926"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "modelname=\"5_6_23_m1\"\n",
    "\n",
    "prefix_models=\"models/\"+modelname+\"/\"\n",
    "\n",
    "if not os.path.exists(prefix_models):\n",
    "    os.makedirs(prefix_models)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Oe3wtt5oADl6"
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "xGOoJdNdRSaO"
   },
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "    def __init__(self, d_model: int, dropout: float = 0.1, max_len: int = 5000):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "\n",
    "        position = torch.arange(max_len).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))\n",
    "        pe = torch.zeros(max_len, 1, d_model)\n",
    "        pe[:, 0, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 0, 1::2] = torch.cos(position * div_term)\n",
    "        self.register_buffer('pe', pe)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        \"\"\"\n",
    "        Arguments:\n",
    "            x: Tensor, shape ``[seq_len, batch_size, embedding_dim]``\n",
    "        \"\"\"\n",
    "        #mine is [batch, seq, embed]\n",
    "        x = x.permute((1,0,2))\n",
    "        x = x + self.pe[:x.size(0)]\n",
    "        dropout = self.dropout(x)\n",
    "        return dropout.permute((1,0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "XakHZ4HfFdYM"
   },
   "outputs": [],
   "source": [
    "class ScaledDotProductAttention(nn.Module):\n",
    "    def forward(self, query, key, value, mask = None):\n",
    "        key_tp = key.transpose(-2, -1)\n",
    "\n",
    "        scores = query.matmul(key_tp) / math.sqrt(query.size()[-1])\n",
    "\n",
    "        if mask is not None:\n",
    "            scores = scores.masked_fill(mask == 0, float(\"-inf\"))\n",
    "            \n",
    "        attention = F.softmax(scores, dim = -1)\n",
    "\n",
    "        return attention.matmul(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "G-sb6gd7L5bR"
   },
   "outputs": [],
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_features,\n",
    "                 head_num,\n",
    "                 bias=True,\n",
    "                 activation=F.relu):\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        if in_features % head_num != 0:\n",
    "            raise ValueError('`in_features`({}) should be divisible by \\\n",
    "                `head_num`({})'.format(in_features, head_num))\n",
    "        self.in_features = in_features\n",
    "        self.head_num = head_num\n",
    "        self.activation = activation\n",
    "        self.bias = bias\n",
    "        self.linear_q = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_k = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_v = nn.Linear(in_features, in_features, bias)\n",
    "        self.linear_o = nn.Linear(in_features, in_features, bias)\n",
    "\n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        q, k, v = self.linear_q(q), self.linear_k(k), self.linear_v(v)\n",
    "        if self.activation is not None:\n",
    "            q = self.activation(q)\n",
    "            k = self.activation(k)\n",
    "            v = self.activation(v)\n",
    "\n",
    "        q = self._reshape_to_batches(q)\n",
    "        k = self._reshape_to_batches(k)\n",
    "        v = self._reshape_to_batches(v)\n",
    "        \n",
    "        if mask is not None:\n",
    "            mask = mask.repeat(self.head_num, 1, 1)   \n",
    "        \n",
    "        y = ScaledDotProductAttention()(q, k, v, mask)        \n",
    "        \n",
    "        y = self._reshape_from_batches(y)      \n",
    "\n",
    "        y = self.linear_o(y)\n",
    "        if self.activation is not None:\n",
    "            y = self.activation(y)\n",
    "        return y\n",
    "\n",
    "    @staticmethod\n",
    "    def gen_causal_mask(x):\n",
    "        batch_size, seq_len, _ = x.size()\n",
    "        return torch.tril(torch.ones(seq_len, seq_len)).view(1, seq_len, seq_len).repeat(batch_size, 1, 1)\n",
    "\n",
    "    def _reshape_to_batches(self, x):\n",
    "        batch_size, seq_len, in_feature = x.size()\n",
    "        sub_dim = in_feature // self.head_num\n",
    "        return x.reshape(batch_size, seq_len, self.head_num, sub_dim)\\\n",
    "                .permute(0, 2, 1, 3)\\\n",
    "                .reshape(batch_size * self.head_num, seq_len, sub_dim)\n",
    "\n",
    "    def _reshape_from_batches(self, x):\n",
    "        batch_size, seq_len, in_feature = x.size()\n",
    "        batch_size //= self.head_num\n",
    "        out_dim = in_feature * self.head_num\n",
    "        return x.reshape(batch_size, self.head_num, seq_len, in_feature)\\\n",
    "                .permute(0, 2, 1, 3)\\\n",
    "                .reshape(batch_size, seq_len, out_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "id": "NDpTASiaTxTX"
   },
   "outputs": [],
   "source": [
    "class Transformer(nn.Module):\n",
    "    def __init__(self, \n",
    "                 embedding_dim: int,\n",
    "                 n_self_heads: int,\n",
    "                 n_features: int,\n",
    "                 n_layers: int,\n",
    "                 n_classes: int,\n",
    "                 n_pad: int):\n",
    "        super().__init__()\n",
    "\n",
    "        #Embedding layer\n",
    "        self.embedding = nn.Embedding(n_features, embedding_dim)\n",
    "        #Positional encoding\n",
    "        self.pos_encode = PositionalEncoding(embedding_dim)\n",
    "\n",
    "        self.decoder_layers = []\n",
    "\n",
    "        for _ in range(n_layers):\n",
    "            layer = []\n",
    "            #Add multihead, which will be cross or self attention\n",
    "            layer.append(MultiHeadAttention(embedding_dim, n_self_heads)) #self attention first, masked\n",
    "            #Now add layer norm\n",
    "            layer.append(nn.LayerNorm(embedding_dim))\n",
    "            #Add feed forward A\n",
    "            layer.append(nn.Linear(embedding_dim, embedding_dim))\n",
    "            #Now add layer norm A\n",
    "            layer.append(nn.LayerNorm(embedding_dim))\n",
    "            #Add feed forward B\n",
    "            layer.append(nn.Linear(embedding_dim, embedding_dim))\n",
    "            #Now add layer norm B\n",
    "            layer.append(nn.LayerNorm(embedding_dim))\n",
    "            \n",
    "            self.decoder_layers.append(nn.ModuleList(layer))\n",
    "        self.decoder_layers=nn.ModuleList(self.decoder_layers)\n",
    "\n",
    "        self.to_out = nn.Linear(embedding_dim, n_classes)\n",
    "        \n",
    "        \n",
    "    def forward(self, x: torch.Tensor, calculate_loss: bool = False):\n",
    "        \"\"\"\n",
    "        Expect tensor of [batch_size, n_features]\n",
    "        \"\"\"\n",
    "        if calculate_loss:\n",
    "            #If give model that accepts ?x?x4 abcd, expect bcd0\n",
    "            \n",
    "            target_logits=torch.cat([x[:,1:], torch.zeros((x.shape[0],1)).to(device)], dim=-1) ## if x is abcd, then target_logits is bcd0\n",
    "\n",
    "        x=x.long().to(device)\n",
    "        embed = self.embedding(x)\n",
    "        pos_encode = self.pos_encode(embed)\n",
    "\n",
    "        res = embed+pos_encode\n",
    "        \n",
    "        for decoder_layer in self.decoder_layers:\n",
    "            d_self_attention = decoder_layer[0]\n",
    "            d_layer_norm_1 = decoder_layer[1]\n",
    "            d_ff_a = decoder_layer[2]\n",
    "            d_layer_norm_2 = decoder_layer[3]\n",
    "            d_ff_b = decoder_layer[4]\n",
    "            d_layer_norm_3 = decoder_layer[5]\n",
    "            \n",
    "            ## Run the decoder\n",
    "            #do masked self attention\n",
    "            mask = MultiHeadAttention.gen_causal_mask(res).to(device)\n",
    "            res = res + d_self_attention(res,res,res, mask = mask)\n",
    "            self_res = res\n",
    "            #layer norm\n",
    "            res = d_layer_norm_1(res)\n",
    "\n",
    "            #do ff a\n",
    "            res = self_res + d_ff_a(res)\n",
    "            #layer norm\n",
    "            res = d_layer_norm_2(res)\n",
    "\n",
    "            #do ff b\n",
    "            res = self_res + d_ff_b(res)\n",
    "            #layer norm\n",
    "            res = d_layer_norm_3(res)\n",
    "\n",
    "        out = self.to_out(res)\n",
    "        if calculate_loss:\n",
    "            loss = nn.functional.cross_entropy(out.permute(0, 2, 1), target_logits.long())\n",
    "            return out,loss\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "id": "HqGGEpvCLbP8"
   },
   "outputs": [],
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, n_pad: int, device: torch.device, pad_byte: int = 0, split: str = \"\\n\"):\n",
    "        self.n_pad = n_pad\n",
    "        self.device = device\n",
    "        self.pad_byte = pad_byte\n",
    "        self.split = split\n",
    "\n",
    "    def tokenize_str(self, sentence: str, encoding = \"utf8\") -> torch.Tensor:\n",
    "        base = [int(i) for i in bytes(sentence, encoding)]\n",
    "        if len(base) < self.n_pad:\n",
    "            base.extend([self.pad_byte] * (self.n_pad - len(base)))\n",
    "        assert len(base) == self.n_pad, f\"n_pad is too small, use {len(base)} or greater.\"\n",
    "        tensor = torch.Tensor(base)\n",
    "        return tensor.to(self.device)\n",
    "\n",
    "    def texts_to_sequences(self, texts: typing.List[str], encoding = \"utf8\") -> torch.Tensor:\n",
    "        # tokenize the input text\n",
    "        sentences = []\n",
    "        for sentence in texts:\n",
    "            sentences.append(self.tokenize_str(sentence).unsqueeze(0))\n",
    "\n",
    "        return torch.cat(sentences, dim = 0).to(self.device)\n",
    "    \n",
    "    @staticmethod\n",
    "    def prepare_texts(document: str) -> typing.List[str]:\n",
    "        return filter(lambda x: len(x)!=0, document.split(self.split))\n",
    "    \n",
    "    def sequences_to_texts(self, texts: torch.Tensor, encoding = \"utf8\") -> typing.List[str]:\n",
    "        out = []\n",
    "        for seq in texts:\n",
    "            chars = []\n",
    "            i=0\n",
    "            while i<len(seq) and seq[i] != 0:\n",
    "                chars.append(int(seq[i]))\n",
    "                i+=1\n",
    "            out.append(bytes(chars).decode(encoding, \"replace\"))\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "id": "pB-Xcf4TkKNQ"
   },
   "outputs": [],
   "source": [
    "def generate(seed: str, cutoff: int = 1024) -> str:\n",
    "    output = torch.tensor([list(bytes(seed,\"utf8\"))]).to(device)\n",
    "    \n",
    "    res=output\n",
    "    last = -1\n",
    "    i=0\n",
    "    while last != 0 and i<cutoff:\n",
    "        res = model(output)\n",
    "        argmax=res.argmax(-1)\n",
    "        \n",
    "        out = list(output[0])\n",
    "        out.append(list(argmax.to(device)[0])[-1])\n",
    "        last = list(argmax.to(device)[0])[-1]\n",
    "        output = torch.tensor([out])\n",
    "        i+=1\n",
    "    \n",
    "    if last == 0:\n",
    "        return convert_to_str(output)\n",
    "    return convert_to_str(output)+\"<CUTOFF>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "id": "R81mAag8mHEG"
   },
   "outputs": [],
   "source": [
    "class TextDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data: typing.List[str], n_pad):\n",
    "        self.raw_data = data\n",
    "        self.tokenizer = Tokenizer(n_pad, device, split = \"\\0\")\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.raw_data)\n",
    "\n",
    "    def __getitem__(self,index):\n",
    "        return self.tokenizer.tokenize_str(self.raw_data[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "id": "xQidsLjVaFUi"
   },
   "outputs": [],
   "source": [
    "def convert_to_str(x: torch.Tensor) -> str:\n",
    "    #Expects [1, 256] tensor\n",
    "    bts = []\n",
    "    i=0\n",
    "    while len(bts)<x.shape[1] and x[0][i] != 0:\n",
    "        bts.append(int(x[0][i]))\n",
    "        i+=1\n",
    "    return bytes(bts).decode(\"utf8\",\"replace\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "id": "97rbDfS4gO8C"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Head size: 8\n"
     ]
    }
   ],
   "source": [
    "n_features = 256 # No. of tokens\n",
    "n_pad = 512 # Max line length\n",
    "embedding_dim = 512\n",
    "batch_size = 32\n",
    "head_factor = 64\n",
    "assert embedding_dim%head_factor == 0\n",
    "head_size = embedding_dim//head_factor\n",
    "print(f\"Head size: {head_size}\")\n",
    "n_layers = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IvvenMeUKfaj",
    "outputId": "fb38b6f5-0eaf-4d89-83ad-bee41604b8ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "187129\n"
     ]
    }
   ],
   "source": [
    "path_to_data = \"data/reddit_scrape_v8.txt\"\n",
    "data_raw = open(path_to_data, encoding=\"utf-8\").read()\n",
    "\n",
    "data_split = list(filter(lambda x: x!=\"\", data_raw.split(\"\\0\")))\n",
    "random.shuffle(data_split)\n",
    "\n",
    "train_data = data_split[100:]\n",
    "print(len(train_data))\n",
    "val_data = data_split[:100]\n",
    "\n",
    "train_dataloader = TextDataset(train_data, n_pad)\n",
    "test_dataloader = TextDataset(train_data, n_pad)\n",
    "\n",
    "dataloader = torch.utils.data.DataLoader(train_dataloader, batch_size=batch_size)\n",
    "testloader = torch.utils.data.DataLoader(test_dataloader , batch_size=1)\n",
    "testloader_iter = iter(testloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "id": "GvibftHanb0A"
   },
   "outputs": [],
   "source": [
    "model = Transformer(embedding_dim, head_size, n_features, n_layers, 256, n_pad)\n",
    "model=model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12894464 trainable params\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(count_parameters(model), \"trainable params\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PXqmUSK0M3hD",
    "outputId": "69ad8160-d138-4e98-99b6-bd8cb83753c1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 512])\n",
      "torch.Size([1, 512, 256])\n"
     ]
    }
   ],
   "source": [
    "input=next(testloader_iter)\n",
    "input=input.to(device)\n",
    "print(input.shape)\n",
    "res = model(input)\n",
    "print(res.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "id": "tZji9Va7-unn"
   },
   "outputs": [],
   "source": [
    "lr = 2e-4\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "#scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "id": "hUN0DJQo-vmf"
   },
   "outputs": [],
   "source": [
    "n_epochs = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GczR7J4u6L5Q",
    "outputId": "15259e58-4468-44ff-dcf3-6c8dfb86d6bc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sat May  6 13:56:22 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 525.85.12    Driver Version: 525.85.12    CUDA Version: 12.0     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|                               |                      |               MIG M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  NVIDIA A10          On   | 00000000:06:00.0 Off |                    0 |\n",
      "|  0%   48C    P0    60W / 150W |  17700MiB / 23028MiB |      0%      Default |\n",
      "|                               |                      |                  N/A |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                                  |\n",
      "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
      "|        ID   ID                                                   Usage      |\n",
      "|=============================================================================|\n",
      "|    0   N/A  N/A     68695      C   /usr/bin/python3                17698MiB |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "id": "yYr65bmbITE1"
   },
   "outputs": [],
   "source": [
    "prompts = [\n",
    "    \"Why does Earth orbit the Sun?\",\n",
    "    \"Hello world, \",\n",
    "    \"How to use ChatGPT?\",\n",
    "    \"My code does not work. What should I do?\",\n",
    "    \"Why is this code not working: `1+\\\"A\\\"`?\",\n",
    "    \"Why is Java better than Python?\",\n",
    "    \"Why is Python better than Java?\",\n",
    "    \"What is the purpose of the main() function in C?\",\n",
    "    \"What is coding?\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o85FrKyF-wg-"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5848/5848 [34:51<00:00,  2.80it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output (raw): Why does Earth orbit the Sun?\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <CUTOFF>\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Hello world, with a computer in the computer of computer and interviews. \n",
       "\n",
       "I am a computer and it in the computer and it is a computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the computer in the past in the computer in the past in the past in the past in the past in the past in the past in the only the past in the only the past is a long the one."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "How to use ChatGPT? \n",
       "I think it is a computer to a computer and it is a computer to a computer and it is a computer to a computer and it is a computer to a little of the computer. It is the computer to the past and the past the past and the past and the past a little of the past in the past and the past the past and the past and the past and the past are the top of the top in the for the only the only the only the past in the only the past in the only the past of the only the past in the oppuly in the the oust."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "My code does not work. What should I do?\n",
       "\n",
       "If you can do this a code and code and code in the code in the code of the code in the code in the code of the code in the code of the production of the code in the code of the code in the code of the code in the one of the one of the one of the one of the production of the production in the one of the one the one of the one of the one of the one of the one the one of the one the one of the one the one of the one the one the one the one the one the one the one the oppes."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output (raw): Why is this code not working: `1+\"A\"`? \n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Why is Java better than Python? \n",
       "\n",
       "If you have a companies are the program that is a companies are and the program that is a companies are and all the life that in the companies are and the companies are the programming the programming the companies and the programming the companies that will be a little of the program that will be a little of the companies to be a little of the companies and the program the program of the program in the one the program of the one the one the one the one the one the opp."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Why is Python better than Java? \n",
       "I think it is a completely in the companies and it is the best to be a first the companies and the companies are the first of the first to the the first of the the office the one of the the first of the of the one of the one of the one of the one of the first of the one of the one of the one of the one of the one of the one of the one of the one of the one of the one of the one of the one the one of the one of the one the one of the one the one the one the one the oppes."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "What is the purpose of the main() function in C?\n",
       "\n",
       "I am a considering in the consider of the considering that is a considering the considering the consider of the consider that is a considering the considering that in the considering the considering the considering the considering of the considering the purpose in the consider of the purpose in the purpose in the function in the function in the function in the function of the function of the purpose in the function in the function of the put in the the functiver t."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output (raw): What is coding? \n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <CUTOFF>\n",
      "\n",
      "Epoch 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5848/5848 [33:59<00:00,  2.87it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt 0: Why does Earth orbit the Sun?\n",
      "Model output (raw): Why does Earth orbit the Sun?  \n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "<CUTOFF>\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output (raw): Hello world,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <CUTOFF>\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "How to use ChatGPT?\n",
       "I think it would be a control in the control of the control in the control in the control of the control in the control of the control in the control of the control of the control in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller in the controller of the controller in the controller of the controller in the controller."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "My code does not work. What should I do?\n",
       "I think it is a complete in the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the complete of the completely of the completely of the completely of the completed."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Why is this code not working: `1+\"A\"`????????????????????????????????.................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Why is Java better than Python?\n",
       "If you have a free that you can a free to a free that you can a find the find the find then the find the find the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the finding the findinding termed to the findinding indending if it."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Why is Python better than Java? If you have a concept that you can a concept in the concept of the concept of the concepts of the concepts of the concepts and then the concepts of the concepts of the concepts and the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts of the concepts.\n",
       "\n",
       "I don't the concepts the concepts."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "What is the purpose of the main() function in C?\n",
       "I think it is a function in the function of the function is a function of the function in the function in the function of the function is a function of the function in the function in the function of the function in the function is the function of the function in the function in the function is a function of the function in the function in the function in the function of the function in the function of the function in the function of the function in the function."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output (markdown): "
     ]
    },
    {
     "data": {
      "text/markdown": [
       "What is coding?????????????????!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 35%|███▍      | 2025/5848 [11:45<22:10,  2.87it/s]"
     ]
    }
   ],
   "source": [
    "model.train()\n",
    "\n",
    "epoch_losses = []\n",
    "for epoch in range(n_epochs):\n",
    "    print(f\"Epoch {epoch+1}\")\n",
    "    \n",
    "    batch_losses = []\n",
    "    for data in tqdm.tqdm(dataloader):\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        data = data.to(device)\n",
    "\n",
    "        output, loss = model(data, True)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        batch_losses.append(loss.item())\n",
    "\n",
    "        \n",
    "    epoch_losses.append(sum(batch_losses)/len(batch_losses))\n",
    "\n",
    "    plt.plot(range(len(batch_losses)),batch_losses)\n",
    "    plt.xlabel(\"Batch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Batch loss\")\n",
    "    plt.show()\n",
    "\n",
    "    plt.plot(range(len(epoch_losses)), epoch_losses)\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.title(\"Epoch loss\")\n",
    "    plt.show()\n",
    "\n",
    "    torch.save(model, prefix_models+f\"model_E{epoch}\")\n",
    "\n",
    "    with open(prefix_models+\"losses.txt\", \"a\") as f:\n",
    "        f.write(f\"{epoch_losses[-1]}\\n\")\n",
    "        \n",
    "    #scheduler.step()    \n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i, prompt in enumerate(prompts):\n",
    "            print(f\"Prompt {i}: {prompt}\")\n",
    "            output=generate(prompt)\n",
    "            if not output.strip().endswith(\"<CUTOFF>\"):\n",
    "                print(f\"Model output (markdown): \", end=\"\")\n",
    "                IPython.display.display(IPython.display.Markdown(output))\n",
    "            else:\n",
    "                print(f\"Model output (raw): {output}\")\n",
    "            print()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DUracnfcZSLX",
    "tags": []
   },
   "outputs": [],
   "source": [
    "model = torch.load(prefix_models+\"model_E0\")\n",
    "\n",
    "with torch.no_grad():\n",
    "    for i, prompt in enumerate(prompts):\n",
    "        print(f\"Prompt {i}: {prompt}\")\n",
    "        output=generate(prompt)\n",
    "        print(f\"Model output: {output}\")\n",
    "        print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r31WSN9YiTuZ"
   },
   "outputs": [],
   "source": [
    "import builtins\n",
    "while True:\n",
    "    prompt = builtins.input(\">>> \")\n",
    "    output=generate(prompt)\n",
    "    print(f\"Model output: {output}\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}