added wraper for all models changed formatting and spelling mistakes.

app.py

@@ -12,17 +12,52 @@ import pandas as pd
 def parse_pipe_sa(pipe_out_text: str):
     output_list = list(pipe_out_text)
     pipe_label = output_list[0]['label']
-    pipe_score = output_list[0]['score']
+    pipe_score = float(output_list[0]['score'])*100
 
     parsed_prediction = 'NULL'
 
     if pipe_label == 'NEGATIVE' or pipe_label == 'LABEL_0':
-        parsed_prediction = f'This model thinks the sentiment is negative with a confidence score of {pipe_score}'
+        parsed_prediction = f'This model thinks the sentiment is NEGATIVE. \nConfidence score of {pipe_score:.3f}%'
     elif pipe_label == 'POSITIVE' or pipe_label == 'LABEL_1':
-        parsed_prediction = f'This model thinks the sentiment is positive with a confidence score of {pipe_score}'
+        parsed_prediction = f'This model thinks the sentiment is POSITIVE. \nConfidence score of {pipe_score:.3f}%'
 
     return parsed_prediction
 
+# Parse sentiment NLI pipeline results
+def parse_pipe_nli(pipe_out_text: str):
+    output_list = pipe_out_text
+    pipe_label = output_list['label']
+    pipe_score = float(output_list['score'])*100
+
+    parsed_prediction = 'NULL'
+
+    if pipe_label == 'NEGATIVE' or pipe_label == 'LABEL_0':
+        parsed_prediction = f'This model thinks the clauses CONFIRM each other. \nConfidence score of {pipe_score:.3f}'
+    elif pipe_label == 'POSITIVE' or pipe_label == 'LABEL_1':
+        parsed_prediction = f'This model thinks the clauses are Neutral. \nConfidence score of {pipe_score:.3f}'
+    elif pipe_label == 'POSITIVE' or pipe_label == 'LABEL_2':
+        parsed_prediction = f'This model thinks the clauses CONTRADICT each other. \nConfidence score of {pipe_score:.3f}'
+
+    return parsed_prediction
+
+# Parse sentiment STS pipeline results
+def parse_pipe_sts(pipe_out_text: str):
+    output_list = pipe_out_text
+    pipe_label = output_list['label']
+    pipe_score = float(output_list['score'])*100
+
+    parsed_prediction = 'NULL'
+
+    if pipe_label == 'NO SIMILARITY' or pipe_label == 'LABEL_0':
+        parsed_prediction = f'This model thinks the clauses have NO similarity. \nConfidence score of {pipe_score:.3f}%'
+    elif pipe_label == 'LITTLE SIMILARITY' or pipe_label == 'LABEL_1':
+        parsed_prediction = f'This model thinks the clauses have LITTLE similarity. \nConfidence score of {pipe_score:.3f}%'
+    elif pipe_label == 'MEDIUM OR HIGHER SIMILARITY' or pipe_label == 'LABEL_2':
+        parsed_prediction = f'This model thinks the clauses have MEDIUM to HIGH similarity. \nConfidence score of {pipe_score:.3f}%'
+
+    return parsed_prediction
+
+#pretty sure this can be removed
 loraModel = AutoPeftModelForSequenceClassification.from_pretrained("Intradiction/text_classification_WithLORA")
 #tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
 tokenizer1 = AutoTokenizer.from_pretrained("albert-base-v2")
@@ -64,13 +99,13 @@ AlbertwithLORA_pipe = pipeline("text-classification",model=sa_merged_model1, tok
 
 #NLI models 
 def AlbertnoLORA_fn(text1, text2):
-    return AlbertnoLORA_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_nli(AlbertnoLORA_pipe({'text': text1, 'text_pair': text2}))
 
 def AlbertwithLORA_fn(text1, text2):
-    return AlbertwithLORA_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_nli(AlbertwithLORA_pipe({'text': text1, 'text_pair': text2}))
 
 def AlbertUntrained_fn(text1, text2):
-    return ALbertUntrained_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_nli(ALbertUntrained_pipe({'text': text1, 'text_pair': text2}))
 
 
 # Handle calls to Deberta--------------------------------------------
@@ -86,14 +121,14 @@ DebertawithLORA_pipe = pipeline("text-classification",model=sa_merged_model2, to
 
 #STS models
 def DebertanoLORA_fn(text1, text2):
-    return DebertanoLORA_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_sts(DebertanoLORA_pipe({'text': text1, 'text_pair': text2}))
 
 def DebertawithLORA_fn(text1, text2):
-    return DebertawithLORA_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_sts(DebertawithLORA_pipe({'text': text1, 'text_pair': text2}))
     #return ("working2")
 
 def DebertaUntrained_fn(text1, text2):
-    return DebertaUntrained_pipe({'text': text1, 'text_pair': text2})
+    return parse_pipe_sts(DebertaUntrained_pipe({'text': text1, 'text_pair': text2}))
 
 #helper functions ------------------------------------------------------
 
@@ -321,10 +356,11 @@ with gr.Blocks(
             with gr.Column(variant="panel"):
                 gr.Markdown("""
                             <h2>Specifications</h2>
-                            <p><b>Model:</b> Tiny Bert <br>
+                            <p><b>Model:</b> Bert Base Uncased <br>
+                            <b>Number of Parameters:</b> 110 Million <br>
                             <b>Dataset:</b> IMDB Movie review dataset <br>
                             <b>NLP Task:</b> Text Classification</p>
-                            <p>Text classification is an NLP task that focuses on automatically ascribing a predefined category or labels to an input prompt. In this demonstration the Tiny Bert model has been used to classify the text on the basis of sentiment analysis, where the labels (negative and positive) will indicate the emotional state expressed by the input prompt. The tiny bert model was chosen as in its base state its ability to perform sentiment analysis is quite poor, displayed by the untrained model, which often fails to correctly ascribe the label to the sentiment. The models were trained on the IMDB dataset which includes over 100k sentiment pairs pulled from IMDB movie reviews. We can see that when training is performed over [XX] of epochs we see an increase in X% of training time for the LoRA trained model.</p>
+                            <p>Text classification is an NLP task that focuses on automatically ascribing a predefined category or labels to an input prompt. In this demonstration the Tiny Bert model has been used to classify the text on the basis of sentiment analysis, where the labels (negative and positive) will indicate the emotional state expressed by the input prompt.<br><br>The models were trained on the IMDB dataset which includes over 100k sentiment pairs pulled from IMDB movie reviews.<br><br><b>Results:</b><br> It can be seen that the LoRA fine tuned model performs comparably to the conventionally trained model. The difference arises in the training time where the conventional model takes almost 30 mins to train through 2 epochs the LoRA model takes half the time to train through 4 epochs.</p>
                             """)
                 
             with gr.Column(variant="panel"):
@@ -371,9 +407,10 @@ with gr.Blocks(
                 gr.Markdown("""
                             <h2>Specifications</h2>
                             <p><b>Model:</b> Albert <br>
+                            <b>Number of Parameters:</b> 11 Million <br>
                             <b>Dataset:</b> Stanford Natural Language Inference Dataset <br>
-                            <b>NLP Task:</b> Natual Languae Infrencing</p>
-                            <p>Natural Language Inference (NLI) which can also be referred to as Textual Entailment is an NLP task with the objective of determining the relationship between two pieces of text. In this demonstration the Albert model has been used to determine textual similarity ascribing a correlation score by the comparison of the two input prompts to determine if. Albert was chosen due to its substandard level of performance in its base state allowing room for improvement during training. The models were trained on the Stanford Natural Language Inference Dataset is a collection of 570k human-written English sentence pairs manually labeled for balanced classification, listed as positive, negative or neutral. We can see that when training is performed over [XX] epochs we see an increase in X% of training time for the LoRA trained model compared to a conventionally tuned model. </p>
+                            <b>NLP Task:</b> Natural Language Inferencing</p>
+                            <p>Natural Language Inference (NLI) which can also be referred to as Textual Entailment is an NLP task with the objective of determining the relationship between two pieces of text. Ideally to determine logical inference (i.e. If the pairs contradict or confirm one another).<br><br>The models were trained on the Stanford Natural Language Inference Dataset which is a collection of 570k human-written English sentence pairs manually labeled for balanced classification, listed as positive, negative or neutral. <br><br><b>Results</b><br>While the time to train for the conventional model may be lower if we look closer at the number of epochs the models we trained over the LoRA model has a time per epoch of 1.5 mins vs the conventional's 3mins per epoch, showing significant improvement. </p>
                             """)
             with gr.Column(variant="panel"):
                 nli_p1 = gr.Textbox(placeholder="Prompt One",label= "Enter Query")
@@ -381,21 +418,21 @@ with gr.Blocks(
                 nli_btn = gr.Button("Run")
                 btnNLIStats = gr.Button("Display Training Metrics")
                 btnTensorLinkNLICon = gr.Button(value="View Conventional Training Graphs", link="https://huggingface.co/m4faisal/NLI-Conventional-Fine-Tuning/tensorboard") 
-                btnTensorLinkNLILora = gr.Button(value="View LoRA Training Graphs", link="https://huggingface.co/m4faisal/NLI-Lora-Fine-Tuning-10K/tensorboard")
+                btnTensorLinkNLILora = gr.Button(value="View LoRA Training Graphs", link="https://huggingface.co/m4faisal/NLI-Lora-Fine-Tuning-10K/tensorboard")    
                 gr.Examples(
                     [
-                        "I am with my friends",
+                        "A man is awake",
                         "People like apples",
-                        "Dogs like bones",
+                        "A game with mutiple people playing",
                     ],
                     nli_p1,
                     label="Try asking",
                 ) 
                 gr.Examples(
                     [
-                        "I am happy",
+                        "A man is sleeping",
                         "Apples are good",
-                        "Bones like dogs",
+                        "Some people are playing a game",
                     ],
                     nli_p2,
                     label="Try asking",
@@ -430,9 +467,10 @@ with gr.Blocks(
                 gr.Markdown("""
                             <h2>Specifications</h2>
                             <p><b>Model:</b> Roberta Base <br>
+                            <b>Number of Parameters:</b> 125 Million <br>
                             <b>Dataset:</b> Semantic Text Similarity Benchmark <br>
                             <b>NLP Task:</b> Semantic Text Similarity</p>
-                            <p>Semantic text similarity measures the closeness in meaning of two pieces of text despite differences in their wording or structure. This task involves two input prompts which can be sentences, phrases or entire documents and assessing them for similarity. In our implementation we compare phrases represented by a score that can range between zero and one. A score of zero implies completely different phrases, while one indicates identical meaning between the text pair. This implementation uses a DeBERTa-v3-xsmall and training was performed on the semantic text similarity benchmark dataset which contains over 86k semantic pairs and their scores. We can see that when training is performed over [XX] epochs we see an increase in X% of training time for the LoRA trained model compared to a conventionally tuned model.</p>
+                            <p>Semantic text similarity measures the closeness in meaning of two pieces of text despite differences in their wording or structure. This task involves two input prompts which can be sentences, phrases or entire documents and assessing them for similarity. <br><br>This implementation uses the Roberta base model and training was performed on the semantic text similarity benchmark dataset which contains over 86k semantic pairs and their scores.<br><br><b>Results</b><br> We can see that for a comparable result the LoRA trained model manages to train for 30 epochs in 14.5 mins vs the conventional models 24 mins displaying a 60% increase in efficiency. </p>
                             """)
             with gr.Column(variant="panel"):
                 sts_p1 = gr.Textbox(placeholder="Prompt One",label= "Enter Query")