Update app.py

app.py

@@ -1,102 +1,81 @@
-import argparse
-import re
-import os
 import streamlit as st
-import random
-import numpy as np
-import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
-import tokenizers
-#os.environ["TOKENIZERS_PARALLELISM"] = "false"
-random.seed(None)
+import torch
+
 first = """informal english: corn fields are all across illinois, visible once you leave chicago.\nTranslated into the Style of Abraham Lincoln: corn fields ( permeate illinois / span the state of illinois / ( occupy / persist in ) all corners of illinois / line the horizon of illinois / envelop the landscape of illinois ), manifesting themselves visibly as one ventures beyond chicago.\n\ninformal english:"""
-suggested_text_list = [first]
-@st.cache(hash_funcs={tokenizers.Tokenizer: id, tokenizers.AddedToken: id})
-def load_model(model_name):
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForCausalLM.from_pretrained(model_name)
+
+@st.cache(allow_output_mutation=True)
+def get_model():
+    print("hello")
+    model = AutoModelForCausalLM.from_pretrained("BigSalmon/InformalToFormalLincoln21")
+    print("hello")
+    tokenizer = AutoTokenizer.from_pretrained("BigSalmon/Points2")
+    print("hello")
     return model, tokenizer
-def extend(input_text, num_return_sequences, bad_words, max_size=20, top_k=50, top_p=0.95):
-    if len(input_text) == 0:
-        input_text = ""
-    encoded_prompt = tokenizer.encode(
-    input_text, add_special_tokens=False, return_tensors="pt")
-    encoded_prompt = encoded_prompt.to(device)
-    if encoded_prompt.size()[-1] == 0:
-        input_ids = None
-    else:
-        input_ids = encoded_prompt    
-    bad_words = bad_words.split()
-    print(bad_words)
-    bad_word_ids = []
-    for bad_word in bad_words: 
-        bad_word = " " + bad_word
-        ids = tokenizer(bad_word).input_ids
-        bad_word_ids.append(ids)
-    
-    output_sequences = model.generate(
-    input_ids=input_ids,
-    max_length=max_size + len(encoded_prompt[0]),
-    top_k=top_k, 
-    bad_words_ids = bad_word_ids,
-    top_p=top_p, 
-    do_sample=True,
-    num_return_sequences=num_return_sequences)
-    # Remove the batch dimension when returning multiple sequences
-    if len(output_sequences.shape) > 2:
-        output_sequences.squeeze_()
-    generated_sequences = []
-    print(output_sequences)
-    for generated_sequence_idx, generated_sequence in enumerate(output_sequences):        
-        generated_sequence = generated_sequence.tolist()
-        text = tokenizer.decode(generated_sequence, clean_up_tokenization_spaces=True)
-        print(text)
-        total_sequence = (
-            text[len(tokenizer.decode(encoded_prompt[0], clean_up_tokenization_spaces=True)) :]
-        )
-        generated_sequences.append(total_sequence)
-        st.write(total_sequence)
-        
-    parsed_text = total_sequence.replace("<|startoftext|>", "").replace("\r","").replace("\n\n", "\n")
-    if len(parsed_text) == 0:
-        parsed_text = "שגיאה"
-    return parsed_text
-if __name__ == "__main__":
-    st.title("GPT2 Demo:")
-    pre_model_path = "BigSalmon/MrLincoln5"
-    model, tokenizer = load_model(pre_model_path)
-    stop_token = "<|endoftext|>"
-    new_lines = "\n\n\n"
-    np.random.seed(None)
-    random_seed = np.random.randint(10000,size=1)    
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    n_gpu = 0 if torch.cuda.is_available()==False else torch.cuda.device_count()
-    torch.manual_seed(random_seed)
-    if n_gpu > 0:
-        torch.cuda.manual_seed_all(random_seed)
-    model.to(device)
-    text_area = st.text_area("Enter the first few words (or leave blank), tap on \"Generate Text\" below. Tapping again will produce a different result.", first)
-    st.sidebar.subheader("Configurable parameters")
-    max_len = st.sidebar.slider("Max-Length", 0, 256, 5,help="The maximum length of the sequence to be generated.")
-    num_return_sequences = st.sidebar.slider("Outputs", 1, 50, 5,help="The number of outputs to be returned.")
-    top_k = st.sidebar.slider("Top-K", 0, 100, 40, help="The number of highest probability vocabulary tokens to keep for top-k-filtering.")
-    top_p = st.sidebar.slider("Top-P", 0.0, 1.0, 0.92, help="If set to float < 1, only the most probable tokens with probabilities that add up to top_p or higher are kept for generation.")
-    bad_words = st.text_input("Words You Do Not Want Generated", " core lemon height time ")
     
-    if st.button("Generate Text"):
-        with st.spinner(text="Generating results..."):
-            st.subheader("Result")
-            print(f"device:{device}, n_gpu:{n_gpu}, random_seed:{random_seed}, maxlen:{max_len}, top_k:{top_k}, top_p:{top_p}")
-            if len(text_area.strip()) == 0:
-                text_area = random.choice(suggested_text_list)
-            result = extend(input_text=text_area,
-                            num_return_sequences=int(num_return_sequences),  
-                            bad_words = bad_words,                       
-                            max_size=int(max_len),                   
-                            top_k=int(top_k),
-                            top_p=float(top_p))
-            print("Done length: " + str(len(result)) + " bytes") 
-            #<div class="rtl" dir="rtl" style="text-align:right;">
-            st.markdown(f"{result}", unsafe_allow_html=True)
-            st.write("\n\nResult length: " + str(len(result)) + " bytes")
-            print(f"\"{result}\"")      
+model, tokenizer = get_model()
+
+st.text('''How To Make Prompt:
+informal english: sega’s doing mobile gaming right with this approach to exploiting its back catalog, giving people a way to build up their library of classics on devices they’ll always have close to hand for cheap. it’s a far better experience than nintendo’s classic machine sales on its home gaming systems, which tend to be locked in and not passed between hardware generations.
+Translated into the Style of Abraham Lincoln: pursuing the proper course, sega's foray into mobile gaming entails leveraging its back catalog of classics on portable devices that ( are certain to be in reach whenever / will be at the ready for use at all times ) ( without spending a fortune / at minimal cost ). such an endeavor comes as a welcome alternative to nintendo's propensity to ( sell / offer / market ) home gaming systems that are rigidly bound to a single hardware generation.
+Translated into the Style of Abraham Lincoln: at a time when nintendo has become inflexible, ( stubbornly bent on / firmly set on / unyielding in its insistence on / steadfastly transfixed by / uncompromising in its commitment to / rigidly decided on ) consoles that are tethered to a fixed iteration, sega diligently curates its legacy of classic video games on handheld devices.
+informal english: garage band has made people who know nothing about music good at creating music.
+Translated into the Style of Abraham Lincoln: garage band ( offers the uninitiated in music the ability to produce professional-quality compositions / catapults those for whom music is an uncharted art the ability the realize masterpieces / stimulates music novice's competency to yield sublime arrangements / begets individuals of rudimentary musical talent the proficiency to fashion elaborate suites ).
+informal english: chrome extensions can make doing regular tasks much easier to get done.
+Translated into the Style of Abraham Lincoln: chrome extensions ( yield the boon of time-saving convenience / ( expedite the ability to / unlock the means to more readily ) accomplish everyday tasks / turbocharges the velocity with which one can conduct their obligations ).
+informal english: broadband is finally expanding to rural areas, a great development that will thrust them into modern life.
+Translated into the Style of Abraham Lincoln: broadband is ( ( finally / at last / after years of delay ) arriving in remote locations / springing to life in far-flung outposts / inching into even the most backwater corners of the nation ) that will ( hasten their transition into the modern age / leap-frog them into the twenty-first century / facilitate their integration into contemporary life ).
+informal english: national parks are a big part of the us culture.
+Translated into the Style of Abraham Lincoln: the culture of the united states is ( inextricably ( bound up with / molded by / enriched by / enlivened by ) its ( serene / picturesque / pristine / breathtaking ) national parks ).
+informal english: corn fields are all across illinois, visible once you leave chicago.
+Translated into the Style of Abraham Lincoln: corn fields ( permeate illinois / span the state of illinois / ( occupy / persist in ) all corners of illinois / line the horizon of illinois / envelop the landscape of illinois ), manifesting themselves visibly as one ventures beyond chicago.
+informal english:''')
+
+temp = st.sidebar.slider("Temperature", 0.7, 1.5)
+number_of_outputs = st.sidebar.slider("Number of Outputs", 5, 50)
+lengths = st.sidebar.slider("Length", 3, 10)
+bad_words = st.text_input("Words You Do Not Want Generated", " core lemon height time ")
+
+def run_generate(text, bad_words):
+  yo = []
+  input_ids = tokenizer.encode(text, return_tensors='pt').to(device)
+  res = len(tokenizer.encode(text))
+  bad_words = bad_words.split()
+  bad_word_ids = []
+  for bad_word in bad_words: 
+    bad_word = " " + bad_word
+    ids = tokenizer(bad_word).input_ids
+    bad_word_ids.append(ids)
+  sample_outputs = model.generate(
+    input_ids,
+    do_sample=True, 
+    max_length= res + lengths, 
+    min_length = res + lengths, 
+    top_k=50,
+    temperature=temp,
+    num_return_sequences=number_of_outputs,
+    bad_words_ids=bad_word_ids
+  )
+  for i in range(number_of_outputs):
+    e = tokenizer.decode(sample_outputs[i])
+    e = e.replace(text, "")
+    yo.append(e)
+  return yo
+with st.form(key='my_form'):
+    text = st.text_area(label='Enter sentence', value=first)
+    submit_button = st.form_submit_button(label='Submit')
+    if submit_button:
+      translated_text = run_generate(text, bad_words)
+      st.write(translated_text if translated_text else "No translation found")
+      with torch.no_grad():
+        text2 = str(text)
+        print(text2)
+        text3 = tokenizer.encode(text2)
+        myinput, past_key_values = torch.tensor([text3]), None
+        myinput = myinput
+        logits, past_key_values = model(myinput, past_key_values = past_key_values, return_dict=False)
+        logits = logits[0,-1]
+        probabilities = torch.nn.functional.softmax(logits)
+        best_logits, best_indices = logits.topk(100)
+        best_words = [tokenizer.decode([idx.item()]) for idx in best_indices]      
+        st.write(best_words)