Duplicate from jaimin/Active

Co-authored-by: Jaimin Mungalpara <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Active
+emoji: 🏢
+colorFrom: red
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.13.0
+app_file: app.py
+pinned: false
+duplicated_from: jaimin/Active
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

adequacy.py

@@ -0,0 +1,40 @@
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+tokenizer = AutoTokenizer.from_pretrained("jaimin/parrot_adequacy_model")
+
+model = AutoModelForSequenceClassification.from_pretrained("jaimin/parrot_adequacy_model")
+
+
+class Adequacy():
+
+    def __init__(self, model_tag='jaimin/parrot_adequacy_model', use_auth_token="access"):
+        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+        self.adequacy_model = AutoModelForSequenceClassification.from_pretrained(model_tag,use_auth_token="access")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_tag,use_auth_token="access")
+
+    def filter(self, input_phrase, para_phrases, adequacy_threshold, device="cpu"):
+        top_adequacy_phrases = []
+        for para_phrase in para_phrases:
+            x = self.tokenizer(input_phrase, para_phrase, return_tensors='pt', max_length=128, truncation=True)
+            self.adequacy_model = self.adequacy_model.to(device)
+            logits = self.adequacy_model(**x).logits
+            probs = logits.softmax(dim=1)
+            prob_label_is_true = probs[:, 1]
+            adequacy_score = prob_label_is_true.item()
+            if adequacy_score >= adequacy_threshold:
+                top_adequacy_phrases.append(para_phrase)
+        return top_adequacy_phrases
+
+    def score(self, input_phrase, para_phrases, adequacy_threshold, device="cpu"):
+        adequacy_scores = {}
+        for para_phrase in para_phrases:
+            x = self.tokenizer(input_phrase, para_phrase, return_tensors='pt', max_length=128, truncation=True)
+            x = x.to(device)
+            self.adequacy_model = self.adequacy_model.to(device)
+            logits = self.adequacy_model(**x).logits
+            probs = logits.softmax(dim=1)
+            prob_label_is_true = probs[:, 1]
+            adequacy_score = prob_label_is_true.item()
+            if adequacy_score >= adequacy_threshold:
+                adequacy_scores[para_phrase] = adequacy_score
+        return adequacy_scores

app.py

@@ -0,0 +1,41 @@
+from styleformer import Styleformer
+import torch
+import warnings
+
+warnings.filterwarnings("ignore")
+import gradio as gr
+
+
+
+def para1(source_sentences):
+        choices = "Active to passive", 
+        sf = Styleformer(style=2)
+        sentance1 = list(source_sentences.split("."))
+        output_sentance = []
+        for source_sentence in sentance1:
+            target_sentence = sf.transfer(source_sentence)
+            if target_sentence is not None:
+                output_sentance.append(target_sentence)
+                #print(target_sentence)
+            else:
+                output_sentance.append(target_sentence)
+                #print(target_sentence)
+                output_sentance.append(target_sentence)
+        res = [i for i in output_sentance if i is not None]
+        #print(output_sentance)
+        #print(res)
+        final = ""
+        for value in res:
+            joint_value = "".join(value)
+            if final == "":
+                final += joint_value
+            else:
+                final = f"{final}.{joint_value}"
+        final = final.replace("..", ".")
+        new_output = final.replace('Active to passive:', "")
+        #print(final)
+        return new_output
+
+iface = gr.Interface(fn=para1, inputs=[gr.inputs.Textbox(lines=5)], outputs="text")
+if __name__ == "__main__":
+    iface.launch(debug=True)

requirements.txt

@@ -0,0 +1,6 @@
+transformers
+torch
+gradio
+sentencepiece
+python-Levenshtein
+fuzzywuzzy

styleformer.py

@@ -0,0 +1,161 @@
+class Styleformer():
+
+    def __init__(
+            self,
+            style=0,
+            ctf_model_tag="jaimin/Informal_to_formal",
+            ftc_model_tag="jaimin/formal_to_informal",
+            atp_model_tag="jaimin/Active_to_passive",
+            pta_model_tag="jaimin/Passive_to_active",
+            adequacy_model_tag="jaimin/parrot_adequacy_model",
+    ):
+        from transformers import AutoTokenizer
+        from transformers import AutoModelForSeq2SeqLM
+        from adequacy import Adequacy
+
+        self.style = style
+        self.adequacy = adequacy_model_tag and Adequacy(model_tag=adequacy_model_tag, use_auth_token="access")
+        self.model_loaded = False
+
+        if self.style == 0:
+            self.ctf_tokenizer = AutoTokenizer.from_pretrained(ctf_model_tag, use_auth_token="access")
+            self.ctf_model = AutoModelForSeq2SeqLM.from_pretrained(ctf_model_tag, use_auth_token="access")
+            print("Casual to Formal model loaded...")
+            self.model_loaded = True
+        elif self.style == 1:
+            self.ftc_tokenizer = AutoTokenizer.from_pretrained(ftc_model_tag, use_auth_token="access")
+            self.ftc_model = AutoModelForSeq2SeqLM.from_pretrained(ftc_model_tag, use_auth_token="access")
+            print("Formal to Casual model loaded...")
+            self.model_loaded = True
+        elif self.style == 2:
+            self.atp_tokenizer = AutoTokenizer.from_pretrained(atp_model_tag,use_auth_token="access")
+            self.atp_model = AutoModelForSeq2SeqLM.from_pretrained(atp_model_tag,use_auth_token="access")
+            print("Active to Passive model loaded...")  
+            self.model_loaded = True
+        elif self.style == 3:
+            self.pta_tokenizer = AutoTokenizer.from_pretrained(pta_model_tag,use_auth_token="access")
+            self.pta_model = AutoModelForSeq2SeqLM.from_pretrained(pta_model_tag,use_auth_token="access")
+            print("Passive to Active model loaded...")        
+            self.model_loaded = True
+        else:
+            print("Only CTF, FTC, ATP and PTA are supported in the pre-release...stay tuned")
+
+    def transfer(self, input_sentence, inference_on=-1, quality_filter=0.95, max_candidates=5):
+        if self.model_loaded:
+            if inference_on == -1:
+                device = "cpu"
+            elif inference_on >= 0 and inference_on < 999:
+                device = "cpu:" + str(inference_on)
+            else:
+                device = "cpu"
+                print("Onnx + Quantisation is not supported in the pre-release...stay tuned.")
+
+            if self.style == 0:
+                output_sentence = self._casual_to_formal(input_sentence, device, quality_filter, max_candidates)
+                return output_sentence
+            elif self.style == 1:
+                output_sentence = self._formal_to_casual(input_sentence, device, quality_filter, max_candidates)
+                return output_sentence
+            elif self.style == 2:
+                output_sentence = self._active_to_passive(input_sentence, device)
+                return output_sentence        
+            elif self.style == 3:
+                output_sentence = self._passive_to_active(input_sentence, device)
+                return output_sentence 
+
+        else:
+            print("Models aren't loaded for this style, please use the right style during init")
+
+    def _formal_to_casual(self, input_sentence, device, quality_filter, max_candidates):
+        ftc_prefix = "transfer Formal to Casual: "
+        src_sentence = input_sentence
+        input_sentence = ftc_prefix + input_sentence
+        input_ids = self.ftc_tokenizer.encode(input_sentence, return_tensors='pt')
+        self.ftc_model = self.ftc_model.to(device)
+        input_ids = input_ids.to(device)
+
+        preds = self.ftc_model.generate(
+            input_ids,
+            do_sample=True,
+            max_length=32,
+            top_k=50,
+            top_p=0.95,
+            early_stopping=True,
+            num_return_sequences=max_candidates)
+
+        gen_sentences = set()
+        for pred in preds:
+            gen_sentences.add(self.ftc_tokenizer.decode(pred, skip_special_tokens=True).strip())
+
+        adequacy_scored_phrases = self.adequacy.score(src_sentence, list(gen_sentences), quality_filter, device)
+        ranked_sentences = sorted(adequacy_scored_phrases.items(), key=lambda x: x[1], reverse=True)
+        if len(ranked_sentences) > 0:
+            return ranked_sentences[0][0]
+        else:
+            return None
+
+    def _casual_to_formal(self, input_sentence, device, quality_filter, max_candidates):
+        ctf_prefix = "transfer Casual to Formal: "
+        src_sentence = input_sentence
+        input_sentence = ctf_prefix + input_sentence
+        input_ids = self.ctf_tokenizer.encode(input_sentence, return_tensors='pt')
+        self.ctf_model = self.ctf_model.to(device)
+        input_ids = input_ids.to(device)
+
+        preds = self.ctf_model.generate(
+            input_ids,
+            do_sample=True,
+            max_length=32,
+            top_k=50,
+            top_p=0.95,
+            early_stopping=True,
+            num_return_sequences=max_candidates)
+
+        gen_sentences = set()
+        for pred in preds:
+            gen_sentences.add(self.ctf_tokenizer.decode(pred, skip_special_tokens=True).strip())
+
+        adequacy_scored_phrases = self.adequacy.score(src_sentence, list(gen_sentences), quality_filter, device)
+        ranked_sentences = sorted(adequacy_scored_phrases.items(), key=lambda x: x[1], reverse=True)
+        if len(ranked_sentences) > 0:
+            return ranked_sentences[0][0]
+        else:
+            return None
+
+    def _active_to_passive(self, input_sentence, device):
+        atp_prefix = "transfer Active to Passive: "
+        src_sentence = input_sentence
+        input_sentence = atp_prefix + input_sentence
+        input_ids = self.atp_tokenizer.encode(input_sentence, return_tensors='pt')
+        self.atp_model = self.atp_model.to(device)
+        input_ids = input_ids.to(device)
+        
+        preds = self.atp_model.generate(
+            input_ids,
+            do_sample=True, 
+            max_length=32, 
+            top_k=50, 
+            top_p=0.95, 
+            early_stopping=True,
+            num_return_sequences=1)
+     
+        return self.atp_tokenizer.decode(preds[0], skip_special_tokens=True).strip()
+
+    def _passive_to_active(self, input_sentence, device):
+        pta_prefix = "transfer Passive to Active: "
+        src_sentence = input_sentence
+        input_sentence = pta_prefix + input_sentence
+        input_ids = self.pta_tokenizer.encode(input_sentence, return_tensors='pt')
+        self.pta_model = self.pta_model.to(device)
+        input_ids = input_ids.to(device)
+        
+        preds = self.pta_model.generate(
+            input_ids,
+            do_sample=True, 
+            max_length=32, 
+            top_k=50, 
+            top_p=0.95, 
+            early_stopping=True,
+            num_return_sequences=1)
+      
+        return self.pta_tokenizer.decode(preds[0], skip_special_tokens=True).strip()