train_v7.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"
   ]
  },
  {
   "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=\"4_30_23_m2\"\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": 9,
   "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",
    "        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 a feed forward\n",
    "            layer.append(nn.Linear(embedding_dim, embedding_dim))\n",
    "            #Now add layer norm\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",
    "    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 = decoder_layer[2]\n",
    "            d_layer_norm_2 = decoder_layer[3]\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\n",
    "            res = self_res + d_ff(res)\n",
    "            #layer norm\n",
    "            res = d_layer_norm_2(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": 10,
   "metadata": {
    "id": "HqGGEpvCLbP8"
   },
   "outputs": [],
   "source": [
    "def tokenize_multi(text_seq: str, features: int, encoding = \"utf8\") -> torch.Tensor:\n",
    "    # tokenize the input text\n",
    "    sentences = []\n",
    "    for sentence in filter(lambda x: x!=\"\", text_seq.split(\"\\n\")):\n",
    "        base = list(bytes(sentence, \"utf8\"))\n",
    "        if len(base) < features:\n",
    "            base.extend([0] * (features - len(base)))\n",
    "        tensor = torch.Tensor(base)\n",
    "        tensor = tensor.unsqueeze(0)\n",
    "        sentences.append(tensor)\n",
    "\n",
    "    return torch.cat(sentences, dim = 0)\n",
    "\n",
    "def tokenize_single(sentence: str, features: int, encoding = \"utf8\") -> torch.Tensor:\n",
    "    base = list(bytes(sentence, \"utf8\"))\n",
    "    if len(base) < features:\n",
    "        base.extend([0] * (features - len(base)))\n",
    "    tensor = torch.Tensor(base)\n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {
    "id": "R81mAag8mHEG"
   },
   "outputs": [],
   "source": [
    "class TextDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data: typing.List[str], features):\n",
    "        self.raw_data = data\n",
    "        self.features = features\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.raw_data)\n",
    "\n",
    "    def __getitem__(self,index):\n",
    "        return tokenize_single(self.raw_data[index], self.features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "97rbDfS4gO8C"
   },
   "outputs": [],
   "source": [
    "n_features = 256 # No. of tokens\n",
    "n_pad = 512 # Max line length\n",
    "embedding_dim = 512\n",
    "batch_size = 48\n",
    "head_factor = 64\n",
    "assert embedding_dim%head_factor == 0\n",
    "head_size = embedding_dim//head_factor\n",
    "n_layers = 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IvvenMeUKfaj",
    "outputId": "fb38b6f5-0eaf-4d89-83ad-bee41604b8ef"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92590\n"
     ]
    }
   ],
   "source": [
    "path_to_data = \"data/reddit_scrape_v6.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": 16,
   "metadata": {
    "id": "GvibftHanb0A"
   },
   "outputs": [],
   "source": [
    "model = Transformer(embedding_dim, head_size, n_features, n_layers, 256)\n",
    "model=model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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",
      "tensor([[189, 200,   7, 216, 230, 208, 183,   1,  16, 193, 146, 173, 230,   1,\n",
      "          84, 217, 217,  84, 208,  70,  21, 176, 189, 217, 177, 230,  21, 187,\n",
      "         230,  16, 216,  16, 183, 157, 217, 189,  16,  16,  27, 230, 208, 200,\n",
      "         189,  96, 217, 217, 200, 176, 189, 217, 230, 157, 217, 183, 189, 230,\n",
      "         183,   1, 236, 183, 118,  96, 230,  63,   7, 230,  21,   1, 183, 217,\n",
      "         217,  83, 208,  70,  70, 176, 189, 146,  21, 200, 236, 230, 183,  21,\n",
      "         176, 189, 145,  37, 183,  33, 183, 114, 200,  61, 193, 199, 183,  37,\n",
      "         208,   1, 208, 183, 216, 230, 157,  61, 114, 199, 189,  18, 217, 183,\n",
      "         200, 199, 199, 189, 216, 176, 217, 189,  37,  37,  37,  59, 176, 157,\n",
      "          16, 230, 189,  80,  16, 188,  16, 208,  18, 183, 230, 183, 217, 200,\n",
      "         188,  18, 189, 189, 189,  80, 217, 189,  16, 189,   1,  83, 217,  34,\n",
      "         176,  18, 217,  16,  56,  16, 230, 118, 230, 148,  16,  61,  80, 230,\n",
      "         216,  32, 208, 189, 197, 157, 236, 188,  19, 183, 217,  19, 157, 217,\n",
      "         220,  59, 200, 183, 157, 189,  32, 208,  33, 200,  18, 236, 189, 217,\n",
      "          21,  19,  19, 118, 200, 118, 217, 183,  56, 208, 200, 135, 189,  21,\n",
      "         118, 216,   1,  39, 135, 118, 118, 123, 123,  95, 121,  19, 208, 146,\n",
      "         209,  18, 220, 189, 217, 121, 193, 217,  70,  16, 208, 183,   1,  16,\n",
      "         193, 216,  59,  59,  37,  37,  37,  37,  37,  37,  37,  62,  37,  62,\n",
      "          37,  62,  62,  62,  62,  62,  62, 188,  62,  62,  99,  37,  37,  37,\n",
      "          62,  59, 114,  59,  37,  37,  37,  37,  59,  59,  59,  59,  59,  37,\n",
      "          59,  37,  59,  37,  37,  37,  37,  62,  62,  37,  62,  37,  37,  99,\n",
      "          37,  37,  37,  59,  37,  37,  62,  62,  62,  62,  37,  37,  37, 191,\n",
      "          59,  59,  59,  59,  59,  59,  37,  59,  37,  37,  37, 191,  37,  59,\n",
      "          37,  37,  37,  37,  62, 191,  37,  37,  59, 191,  37,  37,  37,  37,\n",
      "          99,  59,  99,  59,  59,  59,  59,  59,  37,  37, 130,  59,  37,  37,\n",
      "          99,  59,  37,  37,  37,  99,  37,  37,  37,  37, 130, 130, 130, 130,\n",
      "         130, 130,  99,  99, 130,  99, 130,  37,  99, 130, 114,  37, 130, 130,\n",
      "         130, 130, 130,  99,  99,  99, 191, 191, 191,  37,  37,  59, 130, 191,\n",
      "         191,  37, 191, 130,  37,  37,  37, 191, 191,  37, 130, 191,  62,   2,\n",
      "         191, 130,  37,  37,  37, 191,  37,  37,  37,  37,  62,  37,  37, 191,\n",
      "          37,  37,  37,  37,  37,  37,  37,  37,  37, 130,  59,  59,  37,  59,\n",
      "         130, 130,  37,  37,  37,  37,  37,  37, 130, 130, 130, 130,  37,  37,\n",
      "         130, 130,  37, 130,  37, 130, 130, 130, 130,  37,  37,  37, 130,  37,\n",
      "         130, 130, 130, 130,  37,  37,  37,  37, 130, 130, 130, 130,  37,  37,\n",
      "         130,  59, 130, 130, 130,  37, 130,  37, 130, 130, 130,  37, 130,  59,\n",
      "         130,  37,  37, 130,  59,   2,  37,  37,  37,  37,  37,  37,  37,  37,\n",
      "          37,  37,  37,  37,  37,  37,  37,  37]], device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "input=next(testloader_iter)\n",
    "input=input.to(device)\n",
    "res = model(input)\n",
    "print(input.shape)\n",
    "print(res.shape)\n",
    "print(res.argmax(-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "tZji9Va7-unn"
   },
   "outputs": [],
   "source": [
    "lr = 1e-4\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "hUN0DJQo-vmf"
   },
   "outputs": [],
   "source": [
    "n_epochs = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GczR7J4u6L5Q",
    "outputId": "15259e58-4468-44ff-dcf3-6c8dfb86d6bc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sun Apr 30 18:18:09 2023       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 515.65.01    Driver Version: 515.65.01    CUDA Version: 11.7     |\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%   44C    P0    58W / 150W |   1397MiB / 23028MiB |      6%      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      2519      C   /usr/bin/python3                 1395MiB |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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%|██████████| 1929/1929 [27:34<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "If you would to the are a proges and the son the the sonal the some the some the some the species and the specisifical theread are them are them are them are them are them and the specis and theread and the specis and theread and theread and the specis the specially there are them are them therem and the specically theres and the specicically and the specicial in the specicies and the the specicies intion the the ton the the the the spperice.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, all all there and and the sone the sone the are problem the solve the specifical the specifical the specical and there are problem the specicaly the specicical and therean and in there and the specis the specically there are them and the specical in the are the are the are the them them and the the specicic in the the specicies intint in the the the the spperic int ton the the the the the the there the the the there the therin t ton the the the ther the the ther....\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "In there all there a problem the some the there are them are there are them all the stem the stem the stem the stem the specient they the specition the the specition the specice theread the them the specices the specifical the specicalical and theread the specical the specical in there are the specical and there and the specical the specicial the is the there are the them there the species there the the the spement the the the the there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I want to a sond to the sone the son the sonar all on the son a there are all on the sense the the sens all on the special and theread are there are there are there are them and the specis thereal them and the specis and there specis and theres are there are there and there specis thereses there specintions and there specices and the specices and the specicions and the the specices in the the sperint in the the the there the there there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "In there are there and the there are there are theraing and the stems the stems the specientis the specifical theread the specicition the specically the specically theread the specipale theread are theread and the specically theread the specically they specicicall theread and the specically theread and the specical the specicical in the specical in the species in the specicies intintion to the the there the the there the the there the the there.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "In think the are all and the son the so a special and the stem the specifical the specical and theread and the specises and the specically and theread are theread and the specis theread are therean are them are them are there are therean and the specis there and the specically therean the specically the specicically theres are them are the specicial and the there specinces and the specices intive the tor the the the there the there the the there.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "In think the there are and the there are and the stems the stems the specientific and the specially specisistion there are them and the specision theread and the speciple therem and the specis and theread and the specis therean them are there are there are them them them the specical the specicical theres and the specicial there and the specical there the species the the specicies tis and the the specicies intion ton the the the sppericint int in ton the the the there t ton the there t there t there t there t then t therer t there.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "In there are a speciple there are a problem and the some the some the stem the species the species and the specically specisise and the specis and there speciple the specically and the specis and in theread and the specis and theread and there and the specically therean the specices and the specis in the species and the specical in the specicies in the specicies intiont the tore the the sppecies int ton the the the the there the the there.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I want to a sone the are and and the sone the son the stem the stem the species and the specially and theread are there are there are theread and the specisifical theread are therean are them are them are them are them and the specis theread and theread thereses are therean the speciciall theread there are there are there and there the specis the specintions the species the specis and the specicions and the the specicies and the the there the the sppericint int ton then ton the there t ton the ther the t then t ton there t ther t then t tore t tin t then tin t there t t ton tore t ton t tor t ther t ton t tor t ton ther the t tor t ther ton t the in t in t ther ton t in t tor in t in t the ton t t tor ther t the t in in t t t in t t ton the allllllllllll t ion t in ion ion ion t t t t t t t t t t t on all t t t t t t ton t t ton in in in t t it in t allllllll t ion t al on t t in ion t t t in it t in t t it in in t t in t in t t t in t t t t t t in ther in t ton it t t t t ton t ion t ion it in ion t it it t<CUTOFF>\n",
      "\n",
      "Epoch 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:29<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "If you aren't all there in there aren't and there there are there are there are there there are there are theres on there therese their to there are theres on there their their thereses to there are their thereses their there are their thereses are thereses there are thereses that there are theres are thereses thereses thereses thereses to there are theres to there their there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, there array there array there array there array therary for therapy. \n",
      "Is think there are there are there are there are theres are there are theres on there thereses toricles there are there their thereses to are there are theres are thereses there are thereses thereseseres thereses thereseses thereseses thereses are thereses thereses are thereses are theres are theres on there there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "If you are there are you could there are you aren't any think you aren't there are there. If you would there are yes aren't all there are you aren't there are you aren's there are there. If you want to should there are you are there are aren't there are there. If you aren't there are there are there are theres are there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I wnserver that is a problem that it is the special there in there are are there are there are there are there. It specially to there are there are there are there are theres are theres are theres are theres are theres there are theres are theres are theres there.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <CUTOFF>\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?`` `````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````````<CUTOFF>\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "Is this this a since the since of the school school aren there are are there aren't any there there are there.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <CUTOFF>\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "Is this this is a single there aren't a since there aren't a since there aren's there are there are there.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <CUTOFF>\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I think to this is the since the school state there is a special there aren's there are there.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <CUTOFF>\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "Is think there are all there are there are are theres are there are theres are theres are theres are theres are theres there are theres are theres there their theres are their theres there are theres are their thereses their their thereses to are their their their their aren't theres thereses there are theres are theres there.\n",
      "\n",
      "Epoch 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 175/1929 [02:29<25:09,  1.16it/s]IOPub message rate exceeded.\n",
      "The Jupyter server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--ServerApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "ServerApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "ServerApp.rate_limit_window=3.0 (secs)\n",
      "\n",
      "100%|██████████| 1929/1929 [27:30<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "If you want to use the state there aren't as a lot of the steps of there aren's and there are there are there aren's not there aren's there aren't should benefit there. If you want to shore there are there aren't always there are there aren't so there are there. If you're there are there are there aren't there aren't there are there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, tunes in a senior there. What would be any?\n",
      "I would start the steps that is there aren't a steper that there are there aren's a steper that there are there aren's a probably there are there. I would like there are there aren's a little there aren't there aren't there are there. I wn there are there aren's there are there aren's there aren't there aren't there aren't there are there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "If youre code there are there are there are there aren't always there are there aren't all there aren't all there aren't there aren't any there. I wn there are are there aren's a bit there aren't and there are there aren's there aren't there aren't there aren't there aren't there aren's there aren't there aren't there aren't there aren's there are there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I on thougs one off them there is there are there aren's not there are there aren's as there are there. I wn there are are there aren's a specially there are there aren's a single there are there aren's a bit there aren's there aren's there aren't there aren's there aren's there are there. I wn there are are there are are there aren's there are there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "If you want to do this this should be a problem to the sensor thing you want to learn the same thing you want to learn the same thing you want to do this is there.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "If you want to show the state off the statement of the stem there aren't asserity there are there aren't as a lot of there aren't assert there are there are there are there. I would like there are there are there aren's there are there. I would like there are there are there are there are there. I would there are there are there are there.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "If you want to learn the same is there and there are there are there are there aren's normal there. I have there are there are there aren's a problem that there aren's a little there are there. I would like there are there are there are there aren's there are there. I would there are there are there are there aren's there are there.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would like to sensor the same thing the same there aren't so there are there. I would like there are there aren's a little there aren's there are there. I would like there are there aren's there are there. I wn there are there aren's there are there are there aren's there aren't there aren's there aren't there.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "If you have a loop of them aren't good there. I have a lot of them and I have to there are there. I have a lot of them top there are any thing there. I would like there are a lot of there aren's good there. I would like there are any thing there aren't should be all there.\n",
      "\n",
      "Epoch 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:29<00:00,  1.17it/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": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmt0lEQVR4nO3deXxU9b3/8dcnGyEhIUDCFtaQECBqiyIqAuJWUSm0dtO2t9pWbbW17e92sdsVtfu9/Xm7WLXWaxd73X7e2wotVq2CgCtBQdkTNtkCIUgS1myf3x9ziDEGGCQzZ5J5Px+PPDpzzsnM21PHd875nu8Zc3dERCR5pYQdQEREwqUiEBFJcioCEZEkpyIQEUlyKgIRkSSnIhARSXIqApFOYGZuZsVRbnurmf051plEoqUikG7HzDaZ2UEz29fm586wc4kkqrSwA4jEyAfd/Z9hhxDpCnREIEnFzK4xs+fN7E4zqzWzNWZ2YZv1g81sjpntMbNKM7uuzbpUM/uuma03s3ozW2pmQ9u8/EVmVmFme83sN2ZmUWaaaWYrg99bYGZj26y72cy2Be+39khWM5toZuVmVmdmO83sjk7YPZKkVASSjM4C1gP5wGzgf82sb7DuYWArMBj4KPBjM7sgWPevwFXAZUAu8DngQJvXnQGcCZwGfBy45HhBzGw08BDwNaAAmAfMNbMMMysFvgyc6e45wettCn71l8Av3T0XGAU8ekJ7QKQNFYF0V38N/sI+8nNdm3W7gF+4e6O7PwKsBS4P/ro/F7jZ3Q+5+zLgPuAzwe9dC3zf3dd6xHJ3r2nzuj91973u/iYwH3h/FDk/Afzd3Z9290bg50BPYBLQDPQAxplZurtvcvf1we81AsVmlu/u+9z9pRPeQyIBFYF0Vx9y97w2P79rs26bv/Nui5uJHAEMBva4e327dYXB46FEjiSOpqrN4wNAryhyDg7eAwB3bwG2AIXuXknkSOFWYJeZPWxmg4NNPw+MBtaY2RIzmxHFe4l0SEUgyaiw3fn7YcD24KevmeW0W7cteLyFyGmYzrQdGH7kSZBr6JH3dPcH3X1ysI0DPwuWV7j7VUD/YNljZpbdydkkSagIJBn1B75iZulm9jFgLDDP3bcALwA/MbNMMzuNyF/eR675vw/4gZmVWMRpZtbvJLM8SuS01IVmlg58HTgMvGBmpWZ2gZn1AA4BB4EWADP7tJkVBEcQe4PXajnJLJKkdPmodFdzzay5zfOn3f3DweOXgRJgN7AT+Gibc/1XAfcQ+Uv9LWB2m8tQ7yByzv4pIgPNa4Ajr/meuPtaM/s08Gsip6CWEbn0tSEogJ8SKapGIiV1ffCr04E7zCyLyKmlK9394MlkkeRl+mIaSSZmdg1wbXC6RUTQqSERkaSnIhARSXI6NSQikuR0RCAikuRidtWQmd1PZMr9Lnc/pYP1Y4DfA6cD33P3n0fzuvn5+T5ixIjOjCoi0u0tXbp0t7sXdLQulpeP/gG4E/jTUdbvAb4CfOhEXnTEiBGUl5efVDARkWRjZpuPti5mp4bcfSGR/9gfbf0ud19C5PpoEREJSZcYIzCz64Nb7pZXV1eHHUdEpFvpEkXg7ve6+wR3n1BQ0OEpLhEReY+6RBGIiEjsqAhERJJcLC8ffQiYBuSb2VYi3wSVDuDu95jZQKCcyDc9tZjZ14Bx7l4Xq0wiIvJuMSuC4F7px1pfBQyJ1fuLiEh0kubU0JY9B7ht7koam3XLdhGRtpKmCNZU1fP75zfxxxc2hR1FRCShJE0RXDS2P+eXFvCLf1awq+5Q2HFERBJG0hSBmTH7g2U0NLXw43mrw44jIpIwkqYIAEbkZ3P91CL+umw7L2+oOf4viIgkgaQqAoAvnV9MYV5PZs9ZSZMGjkVEkq8Iemak8m8zxrKmqp4HXjrqzfhERJJG0hUBwCVlA5lSks8dT62juv5w2HFEREKVlEVgZtw6s4xDTc389Ik1YccREQlVUhYBwKiCXnx+chH/8+pWlm4+6tcmiIh0e0lbBAA3XVDMoN6Z3PL4SppbPOw4IiKhSOoiyO6RxvcuH8vK7XU8+LIGjkUkOSV1EQBcfuogJo3qx388uZaafRo4FpHkk/RFYGbcNrOMAw3N/MeTa8OOIyISd0lfBAAlA3L47LkjeKR8C8u27A07johIXKkIAl+5sISCXj245fEVGjgWkaSiIgjkZKbz3cvG8vrWWh5ZsiXsOCIicaMiaGPW+wczcWRf/v3JNby1vyHsOCIicaEiaMPMuH1WGfWHmvj5Uxo4FpHkoCJoZ8zAXD5zznAefOVN3thaG3YcEZGYUxF04GsXjaZfdgb/9vgKWjRwLCLdnIqgA717pvPtS8eybMteHlu6New4IiIxpSI4iivGF3LG8D787B9rqD3QGHYcEZGYUREcRUpKZOD4rQMN3PG0Bo5FpPtSERxD2eDefPrs4Tzw0mZWbtfAsYh0TyqC4/j6xaXkZWUw+/GVuGvgWES6HxXBcfTOSufm6aWUb36Lv7y2Lew4IiKdTkUQhY+dMZT3D83jx/PWUHdIA8ci0r2oCKJwZOC4Zv9hfvF0RdhxREQ6lYogSqcNyePKM4fxxxc3saaqLuw4IiKdRkVwAr51SSk5mWkaOBaRbiVmRWBm95vZLjNbcZT1Zma/MrNKM3vdzE6PVZbO0ic7g29eUsrLG/cwZ/n2sOOIiHSKWB4R/AGYfoz1lwIlwc/1wN0xzNJprjxzGKcW9ubH81az73BT2HFERE5azIrA3RcCe46xySzgTx7xEpBnZoNilaezpKYYt80qY2fdYX71jAaORaTrC3OMoBBo+1VgW4Nl72Jm15tZuZmVV1dXxyXcsZw+rA8fnzCE+xdvpGJnfdhxREROSpcYLHb3e919grtPKCgoCDsOADdPH0NWRiq3ztXAsYh0bWEWwTZgaJvnQ4JlXUK/Xj34xiWlPF9Zw7w3qsKOIyLynoVZBHOAzwRXD50N1Lr7jhDznLBPnTWccYNy+eHfV7FfA8ci0kXF8vLRh4AXgVIz22pmnzezL5rZF4NN5gEbgErgd8CNscoSK6nBjOMdtYe4c35l2HFERN6TtFi9sLtfdZz1DnwpVu8fLxNG9OWK0wu5b9EGPnbGEIoKeoUdSUTkhHSJweJE951Lx5KZlsqtc1dp4FhEuhwVQScoyOnB/7l4NAvXVfPkyp1hxxEROSEqgk7ymXOGUzoghx/8bRUHG5rDjiMiEjUVQSdJS03h9lllbNt7kLsXaOBYRLoOFUEnOquoH7PeP5h7Fm5gc83+sOOIiERFRdDJvnvZWNJTjNvmrgo7iohIVFQEnWxAbiZfvaiEZ9fs4p+rNHAsIolPRRADnz13JMX9e3Hb31ZyqFEDxyKS2FQEMZCemsLtM8vYsucgv31uQ9hxRESOSUUQI5OK87n8tEHctaCSLXsOhB1HROSoVAQx9P3Lx5Jixu1/08CxiCQuFUEMDerdk5suLObpVTuZv3ZX2HFERDqkIoixaycXUZSfzW1zVnK4SQPHIpJ4VAQxlpGWwq0zy9hUc4D7Fm0MO46IyLuoCOJg6ugCppcN5NfPVrBt78Gw44iIvIOKIE6+P2MsAD/UwLGIJBgVQZwM6ZPFl6YV88SKKhZVVIcdR0SklYogjq6bWsTwflnMnrOShqaWsOOIiAAqgrjKTE/l1g+WsaF6P/c/r4FjEUkMKoI4O39Mfy4a259fPVPBjloNHItI+FQEIbhlRhlNLc6P560JO4qIiIogDMP6ZXHDeaOYu3w7L6zfHXYcEUlyKoKQ3DBtFEP79mT24ytpbNbAsYiER0UQksz0VG6ZUUbFrn388YVNYccRkSSmIgjRRWP7M620gF/8s4JddYfCjiMiSUpFECIz49YPltHQ1MJPntDAsYiEQ0UQshH52Vw/tYi/vLaNVzbuCTuOiCQhFUEC+NL5xRTm9eSWx1fQpIFjEYkzFUEC6JmRyvcvH8uaqnoeeGlz2HFEJMmoCBLE9FMGMqUknzueWkd1/eGw44hIElERJAgz49aZZRxqauZn/9DAsYjET0yLwMymm9laM6s0s293sH64mT1jZq+b2QIzGxLLPIluVEEvPj+5iMeWbmXp5rfCjiMiSSJmRWBmqcBvgEuBccBVZjau3WY/B/7k7qcBtwM/iVWeruKmC4oZmJvJLY+voLnFw44jIkkglkcEE4FKd9/g7g3Aw8CsdtuMA54NHs/vYH3Sye6RxvcuH8vK7XU8+MqbYccRkSQQyyIoBLa0eb41WNbWcuCK4PGHgRwz6xfDTF3CjNMGMWlUP37+5Fr27G8IO46IdHNhDxZ/AzjPzF4DzgO2Ac3tNzKz682s3MzKq6u7/9c8mhm3zSxj/+Em/l0DxyISY7Esgm3A0DbPhwTLWrn7dne/wt3HA98Llu1t/0Lufq+7T3D3CQUFBTGMnDhKBuRwzaQRPFK+hWVb9oYdR0S6sVgWwRKgxMxGmlkGcCUwp+0GZpZvZkcyfAe4P4Z5upyvXlRCfq8e3PL4Clo0cCwiMRKzInD3JuDLwJPAauBRd19pZreb2cxgs2nAWjNbBwwAfhSrPF1RTmY637tsLK9vreWR8i3H/wURkffA3LvWX5oTJkzw8vLysGPEjbvziXtfomJnPfO/MY28rIywI4lIF2RmS919Qkfrwh4sluM4MnBcd6iJ/3hybdhxRKQbUhF0AWMH5fIvZw/nwVfe5I2ttWHHEZFuRkXQRfyfi0fTLzuDW+Zo4FhEOpeKoIvo3TOdb186ltfe3Mtjr24NO46IdCMqgi7kivGFnDG8Dz97Yg21BxrDjiMi3YSKoAtJSYkMHL91oIE7ntbAsYh0DhVBF3NKYW8+ddZwHnhpM6u214UdR0S6ARVBF/SND5SSl5XB7Dkr6GrzQEQk8agIuqDeWencPL2UJZve4i+vbTv+L4iIHIOKoIv62BlDed/QPH48bw11hzRwLCLvnYqgi0pJMX4wq4ya/Yf55T8rwo4jIl2YiqALO21IHleeOYw/vLCJtVX1YccRkS4qqiIws+wjt4s2s9FmNtPM0mMbTaLxrUtKyclM45bHNXAsIu9NtEcEC4FMMysEngL+BfhDrEJJ9PpkZ/DNS0p5eeMe5izfHnYcEemCoi0Cc/cDRL5f+C53/xhQFrtYciKuPHMYpxTm8uN5q9l3uCnsOCLSxURdBGZ2DvAp4O/BstTYRJITlZpi3D7rFHbWHebXz2jgWEROTLRF8DUiXyX5l+BbxoqA+TFLJSfs9GF9+PiEIfzX4o1U7tLAsYhEL6oicPfn3H2mu/8sGDTe7e5fiXE2OUE3Tx9DVkYqs+es1MCxiEQt2quGHjSzXDPLBlYAq8zsm7GNJieqX68efP0DpTxfWcO8N6rCjiMiXUS0p4bGuXsd8CHgCWAkkSuHJMF86qxhjB2Uyw//vooDDRo4FpHji7YI0oN5Ax8C5rh7I6BzDwkoLTWFH8wqY0ftIe58tjLsOCLSBURbBL8FNgHZwEIzGw7oHsgJasKIvlxxeiG/W7SBDdX7wo4jIgku2sHiX7l7obtf5hGbgfNjnE1OwrcvHUNmWiq3zl2lgWMROaZoB4t7m9kdZlYe/PxfIkcHkqD652TytYtHs3BdNU+t2hl2HBFJYNGeGrofqAc+HvzUAb+PVSjpHFefM5zSATncPncVBxuaw44jIgkq2iIY5e6z3X1D8HMbUBTLYHLy0lJTuH1WGdv2HuTuBRo4FpGORVsEB81s8pEnZnYucDA2kaQznVXUj1nvH8w9CzewuWZ/2HFEJAFFWwRfBH5jZpvMbBNwJ/CFmKWSTvXdy8aSnmLcNndV2FFEJAFFe9XQcnd/H3AacJq7jwcuiGky6TQDcjP56kUlPLtmF8+s1sCxiLzTCX1DmbvXBTOMAf41BnkkRj577kiK+/fitrmrONSogWMRedvJfFWldVoKibn01BRum1nGm3sO8NvnNoQdR0QSyMkUgWYpdTHnFudz+amDuGtBJVv2HAg7jogkiGMWgZnVm1ldBz/1wODjvbiZTTeztWZWaWbf7mD9MDObb2avmdnrZnbZSfyzSBS+d/lYUsz4wd80cCwiEccsAnfPcffcDn5y3D3tWL9rZqnAb4BLgXHAVWY2rt1m3wceDQafrwTueu//KBKNwXk9uenCYp5atZMFa3eFHUdEEsDJnBo6nolAZTABrQF4GJjVbhsHcoPHvQF9+3ocfH7ySIrys7l1zkoON2ngWCTZxbIICoEtbZ5vDZa1dSvwaTPbCswDburohczs+iP3Oaquro5F1qTSIy2V2TPL2FRzgPsWbQw7joiELJZFEI2rgD+4+xDgMuCB4Ksw38Hd73X3Ce4+oaCgIO4hu6PzRhdwSdkAfv1sBdv2apK4SDKLZRFsA4a2eT4kWNbW54FHAdz9RSATyI9hJmnj32ZEhmx+9HcNHIsks1gWwRKgxMxGmlkGkcHgOe22eRO4EMDMxhIpAp37iZMhfbL40rRi5r1RxeKK3WHHEZGQxKwI3L0J+DLwJLCayNVBK83sdjObGWz2deA6M1sOPARc4/oWlbi6bmoRw/tlccucFTQ0tYQdR0RCYF3tv7sTJkzw8vLysGN0K8+u2cnn/lDOdy4dwxfOGxV2HBGJATNb6u4TOloX9mCxJIALxgzgorH9+eUzFVTVHgo7jojEmYpAALhlRhlNLc6P5q0OO4qIxJmKQAAY1i+LG84bxdzl23lhvQaORZKJikBa3TBtFEP69GT24ytpbNbAsUiyUBFIq8z0VG6ZMY6KXfv44wubwo4jInGiIpB3uHjcAKaVFvCLf1awq04DxyLJQEUg72BmzP5gGQ1NLfzkiTVhxxGROFARyLuMzM/muqkj+ctr2/jWY8vZUL0v7EgiEkPH/E4BSV43XVDC/sPNPPTKm/y/pVu59JSB3DitmFMKe4cdTUQ6mWYWyzHt3neY+xdv5IEXN1N/uImpowv40rRRTBzZFzN9bbVIV3GsmcUqAolK3aFG/vzSZu5fvJHd+xo4Y3gfbpw2igvG9FchiHQBKgLpNIcam3m0fAu/fW4D2/YeZMzAHG6YNorLTx1EWqqGnEQSlYpAOl1jcwtzlm3n7ufWU7lrH8P6ZvGF84r4yOlDyExPDTueiLSjIpCYaWlxnl69k7vmV7J8ay39c3pw7ZSRfPKs4fTqoWsRRBKFikBizt15YX0Ndy2o5PnKGnr3TOfqSSP47KQR9MnOCDueSNJTEUhcLduyl7vmV/LUqp30TE/lqonDuG7qSAb17hl2NJGkpSKQUFTsrOfu59bz+LLtpBhcMX4IX5w2ipH52WFHE0k6KgIJ1ZY9B/jdog08smQLjc0tXHrqIG6cNoqywZqcJhIvKgJJCNX1h7n/+Y38OZicNq20gBunFTNxZN+wo4l0eyoCSSi1B9+enFazv4EJw/vwpfOLmVZaoMlpIjGiIpCEdLAhMjnt3oWRyWljB+W2Tk5LTVEhiHQmFYEktMbmFh5ftp27F1Syvno/w/tl8cXzRnHF6YX0SNPkNJHOoCKQLqGlxXlq1U7uWlDJ61trGZDbg2snF/HJs4aRrclpIidFRSBdirvzfGVkctoL62vIy0rn6nNGcI0mp4m8ZyoC6bJee/Mt7lqwnqdX7SQrI5VPThzGtVOKGNg7M+xoIl2KikC6vLVV9dzz3HrmLN9OqhkfOaOQL0wdxQhNThOJiopAuo0tew7w24XrebR8K03NLVx26iBunFbMuMG5YUcTSWgqAul2dtUf4v7Fm/jzS5vZd7iJ80sLuPH8Ys4coclpIh1REUi3VXuwkQde3MT9z29iz/4GzhzRhxvPL2baaE1OE2lLRSDd3sGGZh5Z8ib3LtzA9tpDjAsmp12myWkigIpAkkhDUwuPL9vG3c+tZ0P1fkbmZ/OFqUV8WJPTJMmFVgRmNh34JZAK3OfuP223/j+B84OnWUB/d8871muqCCQazS3OUyuruGvBet7YVsvA3EyunTKSqyZqcpokp1CKwMxSgXXAxcBWYAlwlbuvOsr2NwHj3f1zx3pdFYGcCHdnUcVu7lpQyUsb9pCXlc5nJ43k6knDycvS5DRJHscqglj+aTQRqHT3DUGIh4FZQIdFAFwFzI5hHklCZsbU0QVMHV3A0s1vcfeCSv7zn+u4d+F6PnlWZHLagFxNTpPklhLD1y4EtrR5vjVY9i5mNhwYCTx7lPXXm1m5mZVXV1d3elBJDmcM78N9V5/JP742hYvHDeC/Fm9kys/m853/fYPNNfvDjicSmlgWwYm4EnjM3Zs7Wunu97r7BHefUFBQEOdo0t2MGZjLL64cz4JvnM/HJgzhf17dyvk/X8BND73G6h11YccTibtYFsE2YGib50OCZR25EngohllE3mVYvyx+9OFTWfyt87luahHPrt7Jpb9cxOf+sITyTXvCjicSN7EcLE4jMlh8IZECWAJ80t1XtttuDPAPYKRHEUaDxRIrtQca+dOLm/j9C5HJaRNH9uXGaaM4T5PTpBs41mBxzI4I3L0J+DLwJLAaeNTdV5rZ7WY2s82mVwIPR1MCIrHUOyudmy4sYfHN53PLjHFs2XOAa36/hBm/XszfX99Bc4v+FZXuSRPKRI6ioamFvy7bxj0L1rNh936K8rP54nmj+ND4QjLSEmV4TSQ6mlkschKaW5wnV1bxm/mVrNxex6DemVw7pYirJg4lK0OT06RrUBGIdAJ3Z2HFbu6aX8nLG/fQJyudz547kqvPGUHvrPSw44kck4pApJMt3byHu+av55k1u8jOSOVTZw/n2skj6a/JaZKgVAQiMbKmqo67F6xn7vLtpKWkcFZRX6aU5DO5uICxg3J0tZEkDBWBSIxtrtnPAy9u5rl11VTs2gdAfq8eTC7ux+SSAqaU5OtWFhIqFYFIHFXVHmJRRTWLK3fzfOVudu9rAGD0gF5MLi5gyuh8zhrZVwPNElcqApGQtLQ4q6vqWFyxm8WVu3l54x4amlrISE3hjOF9mFySz5SSfE4Z3JsUfYGOxJCKQCRBHGpsZsmmPSyq2M2iit2t9zbqk5XOpOJ8phTnM7kknyF9skJOKt1NWLehFpF2MtNTmVJSwJSSyM0Tq+sP83xlpBQWV1bz99d3AFCUnx0cLRRwdlFfcjJ1earEjo4IRBKEu1Oxa1+kFCqqeWnDHg42NpOaYowfmseUkgIml+TzviG9SUvVzGY5MTo1JNIFHW5q5tXNe1lcWc2iit28sa0Wd8jJTGPSqMjVSFNL8hneLzvsqNIFqAhEuoG39jfwwvoaFlVEimHb3oMADO3bk8nFkVKYNCpfs5ylQyoCkW7G3dlUc6C1FF5cX8O+w02kGJw6JI+pJflMLs5n/LA+ukGeACoCkW6vsbmF5Vv2BlcjVbN8ay3NLU5WRirnFPVrvUx1VEEvzXZOUioCkSRTd6iRF4PTSIsrdrOp5gAAg3pnMjm4RHVycT79evUIOanEi4pAJMlt2XOg9RLV5ytrqD3YCEDZ4Fwml+QztaSAM4b3ITM9NeSkEisqAhFp1dzivLGtlsXB+MKrb75FY7PTIy2FiSP7MjW4THXMQN00rztREYjIUe0/3MTLG2taZztXtrlp3pTgFNKUknzdYruL08xiETmq7B5pXDBmABeMGQDAjtqDwaS23SxcV81fXtsGQOmAnMjYQolumtfd6IhARI6qpcVZtaOOxZWRYnhl07tvmje1pICywbm6aV6C06khEekUhxqbeWXjHhZXRo4W1lTVA2/fNG9qST6TSwoozOsZclJpT0UgIjFx5KZ5C4PLVHfVHwagqCA7uJOqbpqXKFQEIhJzR26at3Bd5Et5Xg5umpeWYowfltf6pTynFeqmeWFQEYhI3B1uambp5rdYHFyNtGL7u2+aN35oHsX9e2n+QhyoCEQkdHv2N/DC+t0sWhf5trYjN81LMRiRn83YgbmUDsyhdGAOYwfmMqRPTw1AdyJdPioioeubncGM0wYz47TBuDubaw6wakcda6rqWVtVx4rttcxbsYMjf5tmZ6QyemAOYwbmUDoghzGDchkzMIe8rIxw/0G6IR0RiEjC2H+4iXU761lbVc+aqnrWVEWKYu+BxtZtBuZmUhoUxJhBOZQOyGVU/2x6pOn00rHoiEBEuoTsHmmMH9aH8cP6tC5zd3bVH249clizI1ISL66voaG5BYC0FKOoIJvSgZGjhkhJ5DK4d6ZukxEFFYGIJDQzY0BuJgNyMzlvdEHr8sbmFjbt3t965LC2qp5XN7/F3OXbW7fJyUwLTivlUDowl7EDcxg9MIdcXc76DioCEemS0lNTKBmQQ8mAHD74vsGty+sPNbJuZz2rdxw5xVTH48u2U3/ozdZtCvN6RsYejgxOD8plZH426Ul6WauKQES6lZzMdM4Y3pczhvdtXebu7Kg91DrmsCYoiefWVdPUEhknzUhNYVT/Xq0FETnFlMuA3B7d/vRSTIvAzKYDvwRSgfvc/acdbPNx4FbAgeXu/slYZhKR5GNmDM7ryeC8nq031wNoaGphffU+1lbVszo4vfTShprWG+0B5GWlR04vBeMOpcFVTNk9us/f0TG7asjMUoF1wMXAVmAJcJW7r2qzTQnwKHCBu79lZv3dfdexXldXDYlIrO090NDmyqXIIPXaqnr2NzS3bjOsb1Yw5yEy/jBmUA4j+mWTmqBzH8K6amgiUOnuG4IQDwOzgFVttrkO+I27vwVwvBIQEYmHvKwMzirqx1lF/VqXtbQ42/YeZPWOSCms2VnPmh11PLN6J8HZJXqkpVAyoBdjgquXSoPTSwU5if2VoLEsgkJgS5vnW4Gz2m0zGsDMnidy+uhWd/9H+xcys+uB6wGGDRsWk7AiIseSkmIM7ZvF0L5ZfKBsYOvyQ43NVO7a9/blrcHYw2NLt7Zu0y87o3XOw5hBkdNMJf1z6JmRGHMfwj7JlQaUANOAIcBCMzvV3fe23cjd7wXuhcipoThnFBE5qsz0VE4p7M0phb3fsbxm3+F3TIxbW1XPg69s5lBjZO6DGYzsl9165dKRo4hhfbPifmuNWBbBNmBom+dDgmVtbQVedvdGYKOZrSNSDEtimEtEJOb69erBpOIeTCrOb13W3OK8uecAa6vqWi9vXb2jjn+srGq9tUZWRiolA3IY0zr/IVISfbNjd2uNWA4WpxEZLL6QSAEsAT7p7ivbbDOdyADy1WaWD7wGvN/da472uhosFpHu5kBDExU7973z8tad9ezZ39C6Tf+cHlw3pYjrpha9p/cIZbDY3ZvM7MvAk0TO/9/v7ivN7Hag3N3nBOs+YGargGbgm8cqARGR7igrI433Dc3jfUPzWpe5O9X7DrfOeVhTVU//3NgMOuumcyIiSeBYRwTJOZ9aRERaqQhERJKcikBEJMmpCEREkpyKQEQkyakIRESSnIpARCTJqQhERJJcl5tQZmbVwOb3+Ov5wO5OjNNZEjUXJG425ToxynViumOu4e5e0NGKLlcEJ8PMyo82sy5MiZoLEjebcp0Y5ToxyZZLp4ZERJKcikBEJMklWxHcG3aAo0jUXJC42ZTrxCjXiUmqXEk1RiAiIu+WbEcEIiLSjopARCTJdcsiMLPpZrbWzCrN7NsdrO9hZo8E6182sxEJkusaM6s2s2XBz7VxynW/me0ysxVHWW9m9qsg9+tmdnqC5JpmZrVt9tctccg01Mzmm9kqM1tpZl/tYJu4768oc8V9fwXvm2lmr5jZ8iDbbR1sE/fPZJS5wvpMpprZa2b2tw7Wdf6+cvdu9UPkazHXA0VABrAcGNdumxuBe4LHVwKPJEiua4A7Q9hnU4HTgRVHWX8Z8ARgwNnAywmSaxrwtzjvq0HA6cHjHCLfy93+/8e4768oc8V9fwXva0Cv4HE68DJwdrttwvhMRpMrrM/kvwIPdvT/Vyz2VXc8IpgIVLr7BndvAB4GZrXbZhbwx+DxY8CFZmYJkCsU7r4Q2HOMTWYBf/KIl4A8MxuUALnizt13uPurweN6YDVQ2G6zuO+vKHOFItgP+4Kn6cFP+6tU4v6ZjDJX3JnZEOBy4L6jbNLp+6o7FkEhsKXN8628+wPRuo27NwG1QL8EyAXwkeB0wmNmNjTGmaIVbfYwnBMc2j9hZmXxfOPgkHw8kb8k2wp1fx0jF4S0v4JTHcuAXcDT7n7UfRbHz2Q0uSD+n8lfAN8CWo6yvtP3VXcsgq5sLjDC3U8Dnubt1peOvUrk/invA34N/DVeb2xmvYD/Ab7m7nXxet/jOU6u0PaXuze7+/uBIcBEMzslXu99LFHkiutn0sxmALvcfWks36e97lgE24C2rT0kWNbhNmaWBvQGasLO5e417n44eHofcEaMM0Urmn0ad+5ed+TQ3t3nAelmlh/r9zWzdCL/sf1vd//fDjYJZX8dL1dY+6tdhr3AfGB6u1VhfCaPmyuEz+S5wEwz20Tk9PEFZvbndtt0+r7qjkWwBCgxs5FmlkFkMGVOu23mAFcHjz8KPOvByEuYudqdR55J5DxvIpgDfCa4GuZsoNbdd4QdyswGHjk3amYTifz7HNP/eATv91/Aane/4yibxX1/RZMrjP0VvFeBmeUFj3sCFwNr2m0W989kNLni/Zl09++4+xB3H0HkvxHPuvun223W6fsq7WR+ORG5e5OZfRl4ksiVOve7+0ozux0od/c5RD4wD5hZJZHByCsTJNdXzGwm0BTkuibWuQDM7CEiV5Tkm9lWYDaRgTPc/R5gHpErYSqBA8BnEyTXR4EbzKwJOAhcGYdCPxf4F+CN4NwywHeBYW1yhbG/oskVxv6CyBVNfzSzVCLl86i7/y3sz2SUuUL5TLYX632lW0yIiCS57nhqSEREToCKQEQkyakIRESSnIpARCTJqQhERJKcikCkHTNrbnO3yWXWwZ1iT+K1R9hR7qYqEpZuN49ApBMcDG47IJIUdEQgEiUz22Rm/25mb1jkPvbFwfIRZvZscGOyZ8xsWLB8gJn9JbjJ23IzmxS8VKqZ/c4i98B/KpjVKhIaFYHIu/Vsd2roE23W1br7qcCdRO4SCZEbuP0xuDHZfwO/Cpb/CnguuMnb6cDKYHkJ8Bt3LwP2Ah+J6T+NyHFoZrFIO2a2z917dbB8E3CBu28IbvBW5e79zGw3MMjdG4PlO9w938yqgSFtblp25BbRT7t7SfD8ZiDd3X8Yh380kQ7piEDkxPhRHp+Iw20eN6OxOgmZikDkxHyizf++GDx+gbdv/PUpYFHw+BngBmj9ApTe8QopciL0l4jIu/VscwdPgH+4+5FLSPuY2etE/qq/Klh2E/B7M/smUM3bdxv9KnCvmX2eyF/+NwCh375bpD2NEYhEKRgjmODuu8POItKZdGpIRCTJ6YhARCTJ6YhARCTJqQhERJKcikBEJMmpCEREkpyKQEQkyf1/IhuHNJu6oHcAAAAASUVORK5CYII=\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: Why does Earth orbit the Sun?\n",
      "If you have a look at the stem line in the stem there aren's a little that there is a little that is a little that issue. If you want there are a little that issue is there are all the steps there are there are non there are there. I have there are there are there are there are there are there are there. I had there are there are there are there are there.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, should I hope them I hoper them them in there?\n",
      "I have a senior that in there is a single that is there any there is a single that there is a single that is there aren's a single the same thing that is a single there aren's assusted there. I wn there is a single there are there are there are there are there. I wn there is a single there any there is a single there any there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I used this in the state there are there are normal there. I have the same there are there any there are normal there are there are there are normal there. I have there any there are any thing there are there are normal there are there. I have there any there are there are there are there are there are there are there. I have there any there any there are there are there any there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I have there a one of these theorem arrays there becomes aren's always there are non there are new there. I honely there is a long thing there are and there are there are normal to there. I have there any thing there are always there are all there are all there. I have always there are any there are there are there are there. I have there any there is any also there are there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I wonder if it is there any one of the steps there aren't all theoretical theorems are theory theories theorems are theorems are theories theories their privileges that there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are theres are there are there are theres are theres are theres are theres are theres are theres are theres are theres are their theres.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would start that is there aren't a lot of theories are theory that there are normal theores are normal theorems are theory to be a little that in their problem. I have there are there are there are there are there are there are there are there are there. I think there are there are there are there are there are there.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "If you want the state there and the state of the stack and there are there are normal there. I have the stack and there are there are normal there are normal there. I have there any thing there are normal to there. I have there any thing there are there are there are there are there are there. I had there any there are there are there are there are there.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I hone there are there are there are normal there are there are there aren's all there. I have the sense there are there aren's new there any there are any there. I have the there are there are new there are there are there are there. I had there are there are there are there are there are there are there are there. I had there any there are there are there are there.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I have a loop of theoring and therefore there are normal there are normal there. I have there any one of there intention there is a long that there are new theory to be a little that in there is a little that is a single theoretical and there are there. I wn there is a single thing there are and there are there are there are there are there.\n",
      "\n",
      "Epoch 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:28<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "I have a senior that is the same theory as theory as a significant that is a single theorem and the same theory of their size of the size of the side and the same theory theory theories is there are their steps their and their stering their control their theories their consense.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, should I use it in a pring and should I have a senior in the sensor to the sensor the sense of the stem in the sensor term of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the stem of the sterm in the section of the interned to the send the sterm of the intered to the server in the server in the server the industred.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I use the string in the sem to the sensor the string the sensor the string the sensor the string the sensor the same the sensor the same the sensor the structure the sensor the structure the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the string the striction.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I what yon think is a thinght is and I will hit think there is there in the same side the side of the size of the size of the size of the size of the size of the side there. I would think it is there any the same single thing is there in the same there.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would remote the string the string the side of the side of the size of the side there is a single theory and the string the side there is a single the side of the side there is a single the side on the side there.                                                                                                                                                                                                                                                                                                                                                                                        \n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would start the stem of the stem of the stem of the stem of the stem there. I would start the step there are the step theory theory thing their steps theory their steps theory their interies. I would think there is a stering the stering theory theory theory theory theory theory theory theories in the section theories theory theories theories theories theories theories in their problems.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would remember that is there are a lot of the steps of there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there are there theing their therms.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would remove the software to the state of the state of the state of the state time to the state the state of the state there.                                                                                                                                                                                                                                                                                                                                                                                                                                                \n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "I have a stack and should be a consider that in the same size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the specific to the section of the steps of the steps of the steps of the steps of the steps of the steps of the steps of the steps of the sterm of the sterm of the sterm of the server the sterm on the sterm.\n",
      "\n",
      "Epoch 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:29<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "I have a sen the stem the same the stem of the stem the same theory and the step theory their is a step theory theory thing their steps their problem. I would the same time theory theory is the same theory theory theory theory theory theory theory theory theory theory theory theories in the second theorems are their stering their problems.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, what would bring the stem of the stem of the stem of the stem of the stem of the stem to their intention their intenses?\n",
      "I think you can the step the sensor there is a stem there is a stem there in the sementer there. I would stay the same there is a stem there in the same time there is a stem there is a stem there is a stem there is a stem there is a stem there is a stem the same time there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I always used the string the string the string the string the string the site the string the same the site the string the set the strict is the same the same the same the site the same the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the is the state the is the state in the state is the state in the state is the state in the state in the state in the state.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "\n",
      "I us think the same of in a specifical print in the seconomy of the specific in the specific in the specific is a special specializer of the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the special in the indiving the specious in the specion.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would remove the step the therapy theory theory theory theory theory thing their code to their priviling their printing their code to their printing their code to their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their printing their there.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would start that is the stem of the stem of the stem of the stem there. I would start the stem there is a stem there and the same there are the same there are stem there is a stem there are there any the same site there is a single the stem there. I would start the same time the same stem the same the same sing the stem the same time the stem the same the stem the stem to the stem the stem the stem the stem the stem the stem the sterm to the the ster the thest.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would start that is the step in the same there are normal to the steps the same there. I would start the step the step the step the step the step the step the step the time the step the step the the step the the time the step the the step the time the the step the the step the time the the step the the step the time the the step the time the the stem the the title the the stem the the title the the the title the the title the the title thes the the tit tens the thes tit.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would say that the same thing is the same the same the state the same the state the state the state the state the state the state the stem of the step term in the stem the same the stem the same the stem the same the stem the stem the same the stem the site the stem the same title the stem the stem the stem the stem the stem the stem the stem the stem the stem the stem test the the stem test the the stem test test the the stem the the stes the the tit.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "Inter that is a similar to the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation is a single situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation of the situation.\n",
      "\n",
      "Epoch 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:24<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "I have a state of the state of the state of the state of the state of the state of the state of the state of the state of the state of the state there.                                                                                                                                                                                                                                                                                                                                                                                                                           \n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, i wory follow the study of situations from a condition and site contract the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site of the site in the site of the it.\n",
      "The site is the site there is a site the site there is a singhe.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT?\n",
      "I used to use the code to the code the code to the code the code to the code the code to the code the code the code to the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the code the interves to the code the code the inter these.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "I wis this a secro as the same thing the same thing is a sm thing in the same the same thing in the same they are the same they way. I would think it was a state of the same they are a stem they aren's as the same they are they are a stem they are they are any they aren's they aren's they aren's they aren's they are they are any they are they are are as a single they are they are they are they are they are they are they are they are they.\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n",
      "Model output: Why is this code not working: `1+\"A\"`?\n",
      "I would think the step the theory that the step theory that the step theorem are the step theorem are the theorem that the step theorem the theorem are the theorem theorem theorem theorem theorems theorems theorems theorems they the contribution theories theories their contribution theories theories theories theories their theories theories theories theories theories theories theories theories theories theories theories their theories theories theories theories theis in theirs theirs.\n",
      "\n",
      "Prompt 5: Why is Java better than Python?\n",
      "Model output: Why is Java better than Python?\n",
      "I would start that is a private code that is a statistical code that is a statistical code that is a statistical code that is a statistical statistical and is there is a statistical statistical for the same of the same side that is a since there is a since in the same side that is a since there is a since in the same is a single since there is a since there is a since there is a since there is a since there.\n",
      "\n",
      "Prompt 6: Why is Python better than Java?\n",
      "Model output: Why is Python better than Java?\n",
      "I would start the string the string the string the string the string the string the string the string the string the string the string the string the the string the string the string the string the string the the string the string the the string the string the the string the string the string the string the the string the string the the string the string the the string the string the the string the the string the the string the the string the the string the the the thest.\n",
      "\n",
      "Prompt 7: What is the purpose of the main() function in C?\n",
      "Model output: What is the purpose of the main() function in C?\n",
      "I would say it to a print the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size of the size the size of the size the size of the size the is a since the since the in the stem the in the stem the in the stem the int the int.\n",
      "\n",
      "Prompt 8: What is coding?\n",
      "Model output: What is coding?\n",
      "Interned in this in the stem of the stem of the site the site there. I would stay the site the site of the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the site the is the site the is the site the is the site the is the stem the is the stem the is the is the is the stem.\n",
      "\n",
      "Epoch 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1929/1929 [27:28<00:00,  1.17it/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: Why does Earth orbit the Sun?\n",
      "I have a statistical statistical statistical statistical statistical statistical statistical statistical and statistical statistical statistical statistical statistical and statistical statistical statistical statistical statistical statistical statistical statistical statistical statistical and statistical statistical statistical statistical statistical statistical statistical statistical statistical statistical and statistical statistical statical statical statistical statistical statisticalaged.\n",
      "\n",
      "Prompt 1: Hello world, \n",
      "Model output: Hello world, what would briefly for?\n",
      "I would like the steps and the step the step the step theory theory theory theory that they would be a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that there is a steper that is a sterver is that is a sterver that is a sterver that is a sterver is there.\n",
      "\n",
      "Prompt 2: How to use ChatGPT?\n",
      "Model output: How to use ChatGPT? I have so this and so so so I can use the source chat in the second change in the second source change in the second change the second in any change the change the change the change the change the change the change the change the change the change the change the change the change the change the change the change the change in the change the change in the second in the second in the second in the second in the convenced in and the second in the second in there.\n",
      "\n",
      "Prompt 3: My code does not work. What should I do?\n",
      "Model output: My code does not work. What should I do?\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           <CUTOFF>\n",
      "\n",
      "Prompt 4: Why is this code not working: `1+\"A\"`?\n"
     ]
    }
   ],
   "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",
    "    \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",
    "\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": {
  "accelerator": "GPU",
  "colab": {
   "machine_shape": "hm",
   "provenance": []
  },
  "gpuClass": "premium",
  "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
}