Spaces:
Runtime error
Runtime error
| import streamlit as st | |
| import torch | |
| import json | |
| import torch.nn.functional as F | |
| import pandas as pd | |
| SEED = 42 | |
| def init_count_model(): | |
| return torch.load("count_probs.pt") | |
| def init_single_layer_model(): | |
| return torch.load("single_layer.pt") | |
| def init_mlp(): | |
| mlp_layers = torch.load("mlp.pt") | |
| return mlp_layers["emb"], mlp_layers['w1'], mlp_layers['b1'], mlp_layers['w2'], mlp_layers['b2'] | |
| def init_char_index_mappings(): | |
| with open("ctoi.json") as ci, open("itoc.json") as ic: | |
| return json.load(ci), json.load(ic) | |
| count_p = init_count_model() | |
| single_layer_w = init_single_layer_model() | |
| mlp_emb, mlp_w1, mlp_b1, mlp_w2, mlp_b2 = init_mlp() | |
| ctoi, itoc = init_char_index_mappings() | |
| def predict_with_count(starting_char:str, num_words): | |
| g = torch.Generator().manual_seed(SEED) | |
| output = [] | |
| for _ in range(num_words): | |
| if starting_char not in ctoi: | |
| raise ValueError("Starting Character is not a valid alphabet. Please input a valid alphabet.") | |
| prev = ctoi[starting_char] | |
| out = [] | |
| out.append(starting_char) | |
| while True: | |
| p = count_p[prev] | |
| pred = torch.multinomial(p, num_samples=1, replacement=True, generator=g).item() | |
| out.append(itoc[str(pred)]) | |
| if pred==0: | |
| break # end if '.' is predicted -> end of word | |
| prev = pred | |
| output.append(''.join(out[:-1])) # discard '.' at the end | |
| return output | |
| def predict_with_single_layer_nn(starting_char:str, num_words): | |
| g = torch.Generator().manual_seed(SEED) | |
| output = [] | |
| for _ in range(num_words): | |
| out = [] | |
| if starting_char not in ctoi: | |
| raise ValueError("Starting Character is not a valid alphabet. Please input a valid alphabet.") | |
| ix = ctoi[starting_char] | |
| out.append(starting_char) | |
| while True: | |
| xenc = F.one_hot(torch.tensor([ix]), num_classes=27).float() | |
| logits = xenc @ single_layer_w | |
| counts = logits.exp() | |
| probs = counts/counts.sum(1, keepdim=True) | |
| ix = torch.multinomial(probs, generator=g, replacement=True, num_samples=1).item() | |
| out.append(itoc[str(ix)]) | |
| if ix==0: | |
| break | |
| output.append(''.join(out[:-1])) | |
| return output | |
| def predict_with_mlp(starting_char:str, num_words): | |
| g = torch.Generator().manual_seed(SEED) | |
| output = [] | |
| context_length = 3 | |
| for _ in range(num_words): | |
| out = [] | |
| context = [0]*(context_length-1) | |
| if starting_char not in ctoi: | |
| raise ValueError("Starting Character is not a valid alphabet. Please input a valid alphabet.") | |
| ix = ctoi[starting_char] | |
| out.append(starting_char) | |
| context+=[ix] | |
| while True: | |
| emb = mlp_emb[torch.tensor([context])] | |
| h = torch.tanh(emb.view(1,-1) @ mlp_w1 + mlp_b1) # create batch_size 1 | |
| logits = h @ mlp_w2 + mlp_b2 | |
| probs = F.softmax(logits, dim=1) | |
| ix = torch.multinomial(probs, num_samples=1, generator=g).item() | |
| context = context[1:] + [ix] | |
| out.append(itoc[str(ix)]) | |
| if ix == 0: | |
| break | |
| output.append(''.join(out[:-1])) | |
| return output | |
| def predict(query, num_words): | |
| try: | |
| preds = [predict_with_count(query, num_words), predict_with_single_layer_nn(query, num_words), predict_with_mlp(query, num_words)] | |
| labels = ["Count Based LM", "Single Linear Layer LM", "Embedding Based Single Hidden Layer LM"] | |
| results = {labels[idx]: preds[idx] for idx in range(len(preds))} | |
| st.write(pd.DataFrame(results, index=range(num_words))) | |
| except ValueError as e: | |
| st.write(f"ERROR: {e.args[0]}") | |
| # title and description | |
| st.title(""" | |
| Make More Names. | |
| This app creates the requested number of names starting with the input character below. The results will be predicted from the basic count based to advanced transformer based Character Level Language Model.""") | |
| # search bar | |
| query = st.text_input("Please input the starting character...", "", max_chars=1) | |
| # number of words slider | |
| num_words = st.slider("Number of names to generate:", min_value=1, max_value=50, value=5) | |
| if query != "": | |
| predict(query.lower(), num_words) | |