Initial commit

app.py

@@ -0,0 +1,146 @@
+# References:
+# https://www.tanishq.ai/blog/posts/2021-11-16-gradio-huggingface.html
+
+import numpy as np
+import pandas as pd
+import gradio as gr
+import torch
+from torch import nn
+import pickle
+from torch import tensor
+import torch.nn.functional as F
+import pandas as pd
+
+with open("meta.pkl", "rb") as f:
+    meta = pickle.load(f)
+t2i = meta['t2i']
+i2t = meta['i2t']
+encode = lambda x: [t2i[c] for c in x]
+decode = lambda x: "".join([i2t[i] for i in x])
+
+batch_size = 128 # B, batch size
+block_size = 48 # T, context len for poem is shorter, to set to 48
+vocab_size = len(t2i.keys())
+nn_emb_size = 64 # nn_emb
+n_head = 16
+n_layers = 8
+
+#device = "cuda"
+devicd = "cpu"
+
+def encode_pad(s):
+    if len(s) >= block_size:
+        sample = s[:block_size]
+    else:
+        sample = s
+    sample = encode(s)
+    sample = [0]*(block_size-len(sample)) + sample    
+    inp = tensor(sample[:block_size])[None,...]
+    return inp
+
+class AttentionBlock(nn.Module):
+    def __init__(self, nn_emb = nn_emb_size, block_size = block_size, n_head = n_head):
+        super().__init__()
+        self.nn_emb = nn_emb_size
+        self.block_size = block_size
+        self.n_head = n_head
+
+        self.emb_proj = nn.Linear(nn_emb, nn_emb * 3)
+        self.ln_1 = nn.LayerNorm(nn_emb) 
+        self.mult_head = nn.MultiheadAttention(nn_emb, n_head, dropout=0.2, batch_first=True)
+        self.ln_2 = nn.LayerNorm(nn_emb) 
+        self.ff = nn.Sequential(nn.Linear(nn_emb, nn_emb * 4),nn.GELU(), nn.Dropout(0.2), nn.Linear(nn_emb * 4, nn_emb), nn.GELU(), nn.Dropout(0.2))
+
+    def forward(self,x): # (B, T, nn_emb)
+        x1 = x
+        x = self.emb_proj(x) # (B, T, nn_emb*3)
+        q,k,v = x.split(self.nn_emb, dim=2)
+        x,_ = self.mult_head(q, k, v,  key_padding_mask=None, need_weights=False, attn_mask=torch.nn.Transformer.generate_square_subsequent_mask(self.nn_emb), average_attn_weights=True, is_causal=True) # (B,T,nn_emb)
+        x = x+x1
+        x = self.ff(self.ln_2(x)) + x
+        return x
+        
+        
+class Model(nn.Module):
+    def __init__(self, nn_emb = nn_emb_size, block_size = block_size,vocab_size = vocab_size, n_head = n_head, n_layers = n_layers): 
+        super().__init__()
+        self.vocab_size = vocab_size
+        self.block_size = block_size
+        self.nn_emb = nn_emb
+        self.n_head = n_head
+        self.n_layers = n_layers
+        
+        self.tk_emb = nn.Embedding(vocab_size, nn_emb)
+        self.pos_emb = nn.Embedding(block_size, nn_emb)
+        self.ln = nn.LayerNorm(nn_emb)
+        #self.emb_proj = nn.Linear(nn_emb, nn_emb * 3)
+        #self.atten = nn.MultiheadAttention(nn_emb, n_head, dropout=0.2, batch_first=True)
+        self.attention_blocks = nn.ModuleList( [AttentionBlock(nn_emb, block_size, n_head)] * n_layers)
+        #self.h = nn.Sequential(nn.Linear(nn_emb, nn_emb),nn.GELU(), nn.Dropout(0.2), nn.Linear(nn_emb, nn_emb), nn.GELU(), nn.Dropout(0.2))
+        self.ln_h = nn.Linear(nn_emb, self.vocab_size)
+
+    def forward(self, inp, targ = None): # inp is (B, T), targ is (B, T)
+        inp.to(device)
+        tk = self.tk_emb(inp) # (B,T,nn_emb)
+        positions = torch.arange(self.block_size).to(device)
+        #print(positions)
+        pos = self.pos_emb(positions) # (T,nn_emb)
+        x = tk + pos # (B,T,nn_emb)
+        #x = self.ln(x)        
+        #a = x
+        #x = self.emb_proj(x) # (B,t,nn_emb*3)
+        for blk in self.attention_blocks:
+            x = blk(x)
+        #q,k,v = x.split(self.nn_emb, dim=2)
+        #x,_ = self.atten(q, k, v,  key_padding_mask=None, need_weights=False, attn_mask=torch.nn.Transformer.generate_square_subsequent_mask(self.nn_emb), average_attn_weights=True, is_causal=True) # (B,T,nn_emb)
+        #x = x + a
+        #x = self.ln(x)                
+        #x = x+self.h(x) # (B,T,nn_emb)
+        x = self.ln(x) # (B,T,nn_emb)                
+        x = self.ln_h(x) # (B,T,vocab_size)
+        if targ == None:
+            loss = None
+        else:
+            targ.to(device)
+            loss = F.cross_entropy(x.view(-1, x.shape[-1]), targ.view(-1))
+        return x, loss
+
+m = Model()
+m.to(device)
+
+with open("model_v4.pkl","rb") as f:
+    m=pickle.load(f)
+
+top_k = 20
+def generate(s, num = 60):
+
+    for i in range(num + num):
+        inp = s[-block_size:]
+        inp = encode_pad(inp).to(device)
+        out, loss = m(inp)
+        out = out[:,-1,:]
+        if top_k is not None:
+            v, _ = torch.topk(out, min(top_k, out.size(-1)))
+            out[out < v[:, [-1]]] = -float('Inf')        
+        prob = torch.softmax(out[:,:], dim=-1)
+        g = torch.multinomial(prob, num_samples=1)
+        next_c = i2t[g[0].item()]
+        if next_c in s and next_c != '。' and next_c != '，':
+            continue
+        s = s + next_c
+
+        if (len(s) > num and s[-1] == "。"):
+            break
+    return s
+
+inputs = [gr.Textbox(label="Input",
+            info="Enter some Chinese text to start generate",
+            lines=3,
+            value="终南。",)]
+
+outputs = [ gr.Textbox(
+            label="Output",
+            info="Generated Poem",
+            lines=3,
+            value="", )]
+gr.Interface(fn=generate, inputs=inputs, outputs=outputs, title="Enter Chinese text to generate Chinese Poem.").launch(share=True)

meta.pkl

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

model_v4.pkl

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

webapp.ipynb

@@ -0,0 +1,340 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "1eccc83e-bc68-4082-a3cc-b055779b6ee8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# References:\n",
+    "# https://www.tanishq.ai/blog/posts/2021-11-16-gradio-huggingface.html"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5b74867e-7ec1-4cda-9d96-0f5cd9cd4810",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import gradio as gr\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "import pickle\n",
+    "from torch import tensor\n",
+    "import torch.nn.functional as F\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7d6e9e70-83fe-4209-8f06-6542cf6ba11b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"meta.pkl\", \"rb\") as f:\n",
+    "    meta = pickle.load(f)\n",
+    "t2i = meta['t2i']\n",
+    "i2t = meta['i2t']\n",
+    "encode = lambda x: [t2i[c] for c in x]\n",
+    "decode = lambda x: \"\".join([i2t[i] for i in x])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c4a0b480-6775-4d82-9395-9b5a455012ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size = 128 # B, batch size\n",
+    "block_size = 48 # T, context len for poem is shorter, to set to 48\n",
+    "vocab_size = len(t2i.keys())\n",
+    "nn_emb_size = 64 # nn_emb\n",
+    "n_head = 16\n",
+    "n_layers = 8\n",
+    "\n",
+    "#device = \"cuda\"\n",
+    "devicd = \"cpu\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0e4e72ce-5f61-4831-b7e8-703ed171936b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def encode_pad(s):\n",
+    "    if len(s) >= block_size:\n",
+    "        sample = s[:block_size]\n",
+    "    else:\n",
+    "        sample = s\n",
+    "    sample = encode(s)\n",
+    "    sample = [0]*(block_size-len(sample)) + sample    \n",
+    "    inp = tensor(sample[:block_size])[None,...]\n",
+    "    return inp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a9bc886f-4ec8-458a-b847-c9996df57fa9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Model(\n",
+       "  (tk_emb): Embedding(7475, 64)\n",
+       "  (pos_emb): Embedding(48, 64)\n",
+       "  (ln): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
+       "  (attention_blocks): ModuleList(\n",
+       "    (0-7): 8 x AttentionBlock(\n",
+       "      (emb_proj): Linear(in_features=64, out_features=192, bias=True)\n",
+       "      (ln_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
+       "      (mult_head): MultiheadAttention(\n",
+       "        (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
+       "      )\n",
+       "      (ln_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
+       "      (ff): Sequential(\n",
+       "        (0): Linear(in_features=64, out_features=256, bias=True)\n",
+       "        (1): GELU(approximate='none')\n",
+       "        (2): Dropout(p=0.2, inplace=False)\n",
+       "        (3): Linear(in_features=256, out_features=64, bias=True)\n",
+       "        (4): GELU(approximate='none')\n",
+       "        (5): Dropout(p=0.2, inplace=False)\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (ln_h): Linear(in_features=64, out_features=7475, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class AttentionBlock(nn.Module):\n",
+    "    def __init__(self, nn_emb = nn_emb_size, block_size = block_size, n_head = n_head):\n",
+    "        super().__init__()\n",
+    "        self.nn_emb = nn_emb_size\n",
+    "        self.block_size = block_size\n",
+    "        self.n_head = n_head\n",
+    "\n",
+    "        self.emb_proj = nn.Linear(nn_emb, nn_emb * 3)\n",
+    "        self.ln_1 = nn.LayerNorm(nn_emb) \n",
+    "        self.mult_head = nn.MultiheadAttention(nn_emb, n_head, dropout=0.2, batch_first=True)\n",
+    "        self.ln_2 = nn.LayerNorm(nn_emb) \n",
+    "        self.ff = nn.Sequential(nn.Linear(nn_emb, nn_emb * 4),nn.GELU(), nn.Dropout(0.2), nn.Linear(nn_emb * 4, nn_emb), nn.GELU(), nn.Dropout(0.2))\n",
+    "\n",
+    "    def forward(self,x): # (B, T, nn_emb)\n",
+    "        x1 = x\n",
+    "        x = self.emb_proj(x) # (B, T, nn_emb*3)\n",
+    "        q,k,v = x.split(self.nn_emb, dim=2)\n",
+    "        x,_ = self.mult_head(q, k, v,  key_padding_mask=None, need_weights=False, attn_mask=torch.nn.Transformer.generate_square_subsequent_mask(self.nn_emb), average_attn_weights=True, is_causal=True) # (B,T,nn_emb)\n",
+    "        x = x+x1\n",
+    "        x = self.ff(self.ln_2(x)) + x\n",
+    "        return x\n",
+    "        \n",
+    "        \n",
+    "class Model(nn.Module):\n",
+    "    def __init__(self, nn_emb = nn_emb_size, block_size = block_size,vocab_size = vocab_size, n_head = n_head, n_layers = n_layers): \n",
+    "        super().__init__()\n",
+    "        self.vocab_size = vocab_size\n",
+    "        self.block_size = block_size\n",
+    "        self.nn_emb = nn_emb\n",
+    "        self.n_head = n_head\n",
+    "        self.n_layers = n_layers\n",
+    "        \n",
+    "        self.tk_emb = nn.Embedding(vocab_size, nn_emb)\n",
+    "        self.pos_emb = nn.Embedding(block_size, nn_emb)\n",
+    "        self.ln = nn.LayerNorm(nn_emb)\n",
+    "        #self.emb_proj = nn.Linear(nn_emb, nn_emb * 3)\n",
+    "        #self.atten = nn.MultiheadAttention(nn_emb, n_head, dropout=0.2, batch_first=True)\n",
+    "        self.attention_blocks = nn.ModuleList( [AttentionBlock(nn_emb, block_size, n_head)] * n_layers)\n",
+    "        #self.h = nn.Sequential(nn.Linear(nn_emb, nn_emb),nn.GELU(), nn.Dropout(0.2), nn.Linear(nn_emb, nn_emb), nn.GELU(), nn.Dropout(0.2))\n",
+    "        self.ln_h = nn.Linear(nn_emb, self.vocab_size)\n",
+    "\n",
+    "    def forward(self, inp, targ = None): # inp is (B, T), targ is (B, T)\n",
+    "        inp.to(device)\n",
+    "        tk = self.tk_emb(inp) # (B,T,nn_emb)\n",
+    "        positions = torch.arange(self.block_size).to(device)\n",
+    "        #print(positions)\n",
+    "        pos = self.pos_emb(positions) # (T,nn_emb)\n",
+    "        x = tk + pos # (B,T,nn_emb)\n",
+    "        #x = self.ln(x)        \n",
+    "        #a = x\n",
+    "        #x = self.emb_proj(x) # (B,t,nn_emb*3)\n",
+    "        for blk in self.attention_blocks:\n",
+    "            x = blk(x)\n",
+    "        #q,k,v = x.split(self.nn_emb, dim=2)\n",
+    "        #x,_ = self.atten(q, k, v,  key_padding_mask=None, need_weights=False, attn_mask=torch.nn.Transformer.generate_square_subsequent_mask(self.nn_emb), average_attn_weights=True, is_causal=True) # (B,T,nn_emb)\n",
+    "        #x = x + a\n",
+    "        #x = self.ln(x)                \n",
+    "        #x = x+self.h(x) # (B,T,nn_emb)\n",
+    "        x = self.ln(x) # (B,T,nn_emb)                \n",
+    "        x = self.ln_h(x) # (B,T,vocab_size)\n",
+    "        if targ == None:\n",
+    "            loss = None\n",
+    "        else:\n",
+    "            targ.to(device)\n",
+    "            loss = F.cross_entropy(x.view(-1, x.shape[-1]), targ.view(-1))\n",
+    "        return x, loss\n",
+    "\n",
+    "m = Model()\n",
+    "m.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "95545bf7-51fa-45a8-b34d-0231aa95e300",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"model_v4.pkl\",\"rb\") as f:\n",
+    "    m=pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "c2393e78-a1c6-4671-9170-4ea33cdb50d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "top_k = 20\n",
+    "def generate(s, num = 60):\n",
+    "\n",
+    "    for i in range(num + num):\n",
+    "        inp = s[-block_size:]\n",
+    "        inp = encode_pad(inp).to(device)\n",
+    "        out, loss = m(inp)\n",
+    "        out = out[:,-1,:]\n",
+    "        if top_k is not None:\n",
+    "            v, _ = torch.topk(out, min(top_k, out.size(-1)))\n",
+    "            out[out < v[:, [-1]]] = -float('Inf')        \n",
+    "        prob = torch.softmax(out[:,:], dim=-1)\n",
+    "        g = torch.multinomial(prob, num_samples=1)\n",
+    "        next_c = i2t[g[0].item()]\n",
+    "        if next_c in s and next_c != '。' and next_c != '，':\n",
+    "            continue\n",
+    "        s = s + next_c\n",
+    "\n",
+    "        if (len(s) > num and s[-1] == \"。\"):\n",
+    "            break\n",
+    "    return s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "170b95ca-74b9-4360-84cc-6a8dfa3f8c42",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'终南。若问黄云一路在，更有东城上去时。不须为别故园庐，独坐江山半夜凉。此地无馀春树晚，今朝日暮向来迟。西北天津长望后，三湘月下烟中。'"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate('终南。')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "edca19ab-087b-4368-84d0-8eee7388c200",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7867\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7867/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "inputs = [gr.Textbox(label=\"Input\",\n",
+    "            info=\"Enter some Chinese text to start generate\",\n",
+    "            lines=3,\n",
+    "            value=\"终南。\",)]\n",
+    "\n",
+    "outputs = [ gr.Textbox(\n",
+    "            label=\"Output\",\n",
+    "            info=\"Generated Poem\",\n",
+    "            lines=3,\n",
+    "            value=\"\", )]\n",
+    "gr.Interface(fn=generate, inputs=inputs, outputs=outputs, title=\"Enter Chinese text to generate Chinese Poem.\").launch(share=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6112eaea-16d6-4d43-8b95-3999c605643b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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": 5
+}