Initial commit

InferenceServer.py

@@ -1 +1,67 @@
-print("hello world")
+import uvicorn
+from fastapi import File
+from fastapi import FastAPI
+from fastapi import UploadFile
+import torch
+import os
+import sys
+import glob
+import transformers
+from transformers import AutoTokenizer
+from transformers import AutoModelForSeq2SeqLM
+from lm_scorer.models.auto import AutoLMScorer as LMScorer
+
+
+print("Loading models...")
+app = FastAPI()
+
+device = "cpu"
+batch_size = 1    
+scorer = LMScorer.from_pretrained("gpt2", device=device, batch_size=batch_size)    
+correction_model_tag = "prithivida/grammar_error_correcter_v2"
+correction_tokenizer = AutoTokenizer.from_pretrained(correction_model_tag)
+correction_model     = AutoModelForSeq2SeqLM.from_pretrained(correction_model_tag)
+
+def set_seed(seed):
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+print("Models loaded !")
+
+
+@app.get("/")
+def read_root():
+    return {"Gramformer !"}
+
+@app.get("/{correct}")
+def get_correction(input_sentence):
+    set_seed(1212)
+    scored_corrected_sentence = correct(input_sentence)
+    return {"scored_corrected_sentence": scored_corrected_sentence}
+
+def correct(input_sentence, max_candidates=1):
+    correction_prefix = "gec: "
+    input_sentence = correction_prefix + input_sentence
+    input_ids = correction_tokenizer.encode(input_sentence, return_tensors='pt')
+    input_ids = input_ids.to(device)
+
+    preds = correction_model.generate(
+        input_ids,
+        do_sample=True, 
+        max_length=128, 
+        top_k=50, 
+        top_p=0.95, 
+        early_stopping=True,
+        num_return_sequences=max_candidates)
+
+    corrected = set()
+    for pred in preds:  
+        corrected.add(correction_tokenizer.decode(pred, skip_special_tokens=True).strip())
+
+    corrected = list(corrected)
+    scores = scorer.sentence_score(corrected, log=True)
+    ranked_corrected = [(c,s) for c, s in zip(corrected, scores)]
+    ranked_corrected.sort(key = lambda x:x[1], reverse=True)
+    return ranked_corrected
+

app.py

@@ -0,0 +1,211 @@
+from annotated_text import annotated_text
+from bs4 import BeautifulSoup
+from multiprocessing import Process
+import streamlit as st
+import pandas as pd
+import torch
+import math
+import re
+import time
+import json
+import os
+import requests
+import spacy
+import errant
+
+
+
+def start_server():    
+    os.system("cat custom_req.txt | xargs -n 1 -L 1 pip install -U")
+    os.system("uvicorn InferenceServer:app --port 8080 --host 0.0.0.0 --workers 1")
+
+def load_models():
+    if not is_port_in_use(8080):
+        with st.spinner(text="Loading models, please wait..."):
+            proc = Process(target=start_server, args=(), daemon=True)
+            proc.start()
+            while not is_port_in_use(8080):
+                time.sleep(1)
+            st.success("Model server started.")
+    else:
+        st.success("Model server already running...")
+    st.session_state['models_loaded'] = True
+
+def is_port_in_use(port):
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(('0.0.0.0', port)) == 0
+
+if 'models_loaded' not in st.session_state:
+    st.session_state['models_loaded'] = False
+
+
+def show_highlights(input_text, corrected_sentence):
+    """
+        To show highlights
+    """
+    try:
+        strikeout = lambda x: '\u0336'.join(x) + '\u0336'
+        highlight_text = highlight(input_text, corrected_sentence)
+        color_map = {'d':'#faa', 'a':'#afa', 'c':'#fea'}
+        tokens = re.split(r'(<[dac]\s.*?<\/[dac]>)', highlight_text)
+        annotations = []
+        for token in tokens:
+            soup = BeautifulSoup(token, 'html.parser')
+            tags = soup.findAll()
+            if tags:
+                _tag = tags[0].name
+                _type = tags[0]['type']
+                _text = tags[0]['edit']
+                _color = color_map[_tag]
+
+                if _tag == 'd':
+                    _text = strikeout(tags[0].text)
+
+                annotations.append((_text, _type, _color))
+            else:
+                annotations.append(token)
+        annotated_text(*annotations)
+    except Exception as e:
+        st.error('Some error occured!' + str(e))
+        st.stop()
+
+def show_edits(input_text, corrected_sentence):
+    """
+        To show edits
+    """
+    try:
+        edits = get_edits(input_text, corrected_sentence)
+        df = pd.DataFrame(edits, columns=['type','original word', 'original start', 'original end', 'correct word', 'correct start', 'correct end'])
+        df = df.set_index('type')
+        st.table(df)
+    except Exception as e:
+        st.error('Some error occured!')
+        st.stop()
+
+def highlight(orig, cor):
+      edits = _get_edits(orig, cor)
+      orig_tokens = orig.split()
+
+      ignore_indexes = []
+
+      for edit in edits:
+          edit_type = edit[0]
+          edit_str_start = edit[1]
+          edit_spos = edit[2]
+          edit_epos = edit[3]
+          edit_str_end = edit[4]
+
+          # if no_of_tokens(edit_str_start) > 1 ==> excluding the first token, mark all other tokens for deletion
+          for i in range(edit_spos+1, edit_epos):
+            ignore_indexes.append(i)
+
+          if edit_str_start == "":
+              if edit_spos - 1 >= 0:
+                  new_edit_str = orig_tokens[edit_spos - 1]
+                  edit_spos -= 1
+              else:
+                  new_edit_str = orig_tokens[edit_spos + 1]
+                  edit_spos += 1
+              if edit_type == "PUNCT":
+                st = "<a type='" + edit_type + "' edit='" + \
+                    edit_str_end + "'>" + new_edit_str + "</a>"
+              else:
+                st = "<a type='" + edit_type + "' edit='" + new_edit_str + \
+                    " " + edit_str_end + "'>" + new_edit_str + "</a>"
+              orig_tokens[edit_spos] = st
+          elif edit_str_end == "":
+            st = "<d type='" + edit_type + "' edit=''>" + edit_str_start + "</d>"
+            orig_tokens[edit_spos] = st
+          else:
+            st = "<c type='" + edit_type + "' edit='" + \
+                edit_str_end + "'>" + edit_str_start + "</c>"
+            orig_tokens[edit_spos] = st
+
+      for i in sorted(ignore_indexes, reverse=True):
+        del(orig_tokens[i])
+
+      return(" ".join(orig_tokens))
+
+
+def _get_edits(orig, cor):
+    orig = annotator.parse(orig)
+    cor = annotator.parse(cor)
+    alignment = annotator.align(orig, cor)
+    edits = annotator.merge(alignment)
+
+    if len(edits) == 0:  
+        return []
+
+    edit_annotations = []
+    for e in edits:
+        e = annotator.classify(e)
+        edit_annotations.append((e.type[2:], e.o_str, e.o_start, e.o_end,  e.c_str, e.c_start, e.c_end))
+            
+    if len(edit_annotations) > 0:
+        return edit_annotations
+    else:    
+        return []
+
+def get_edits(orig, cor):
+    return _get_edits(orig, cor)        
+
+def get_correction(input_text):
+    correct_request = "http://0.0.0.0:8080/correct?input_sentence="+input_text
+    correct_response = requests.get(correct_request)
+    correct_json = json.loads(correct_response.text)
+    scored_corrected_sentence = correct_json["scored_corrected_sentence"]
+    
+    corrected_sentence, score = scored_corrected_sentence[0]
+    st.markdown(f'##### Corrected text:')
+    st.write('')
+    st.success(corrected_sentence)
+    exp1 = st.expander(label='Show highlights', expanded=True)
+    with exp1:
+        show_highlights(input_text, corrected_sentence)
+    exp2 = st.expander(label='Show edits')
+    with exp2:
+        show_edits(input_text, corrected_sentence)
+          
+        
+if __name__ == "__main__":
+    if not st.session_state['models_loaded']:
+        load_models() 
+
+
+st.title('Gramformer')
+st.subheader('A framework for correcting english grammatical errors')
+st.markdown("Built for fun with 💙  by a quintessential foodie - Prithivi Da, The maker of [WhatTheFood](https://huggingface.co/spaces/prithivida/WhatTheFood), [Styleformer](https://github.com/PrithivirajDamodaran/Styleformer) and [Parrot paraphraser](https://github.com/PrithivirajDamodaran/Parrot_Paraphraser) | ✍️ [@prithivida](https://twitter.com/prithivida) |[[GitHub]](https://github.com/PrithivirajDamodaran)", unsafe_allow_html=True)
+
+examples = [
+            "what be the reason for everyone leave the comapny",
+            "He are moving here.",
+            "I am doing fine. How is you?",
+            "How is they?",
+            "Matt like fish",
+            "the collection of letters was original used by the ancient Romans",
+            "We enjoys horror movies",
+            "Anna and Mike is going skiing",
+            "I walk to the store and I bought milk",
+            " We all eat the fish and then made dessert",
+            "I will eat fish for dinner and drink milk",
+            ]
+
+nlp = spacy.load('en_core_web_sm')
+annotator = errant.load('en', nlp)
+
+input_text = st.selectbox(
+label="Choose an example",
+options=examples
+)
+st.write("(or)")
+input_text = st.text_input(
+    label="Enter your own text",
+    value=input_text
+)
+
+if input_text.strip(): 
+    get_correction(input_text)
+
+
+

custom_req.txt

@@ -0,0 +1,14 @@
+st-annotated-text
+bs4 
+torch
+fastapi
+uvicorn
+spacy==2.3.0
+python-Levenshtein==0.12.2
+errant==2.2.0
+lm-scorer==0.4.2
+fsspec==2021.5.0
+tokenizers
+fuzzywuzzy==0.18.0
+sentencepiece==0.1.95
+transformers