adding GPT part

app.py

@@ -1,396 +1,324 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-# In[ ]:
-
-
-import numpy as np
-import tensorflow as tf
-import tensorflow_addons as tfa
-from tensorflow.keras import layers
-import transformers
-import sentencepiece as spm
-#show the version of the package imported with text instructions\
-print("Tensorflow version: ", tf.__version__)
-print("Tensorflow Addons version: ", tfa.__version__)
-print("Transformers version: ", transformers.__version__)
-print("Sentencepiece version: ", spm.__version__)
-print("Numpy version: ", np.__version__)
-
-
-# In[ ]:
-
-
-class MeanPool(tf.keras.layers.Layer):
-    def call(self, inputs, mask=None):
-        broadcast_mask = tf.expand_dims(tf.cast(mask, "float32"), -1)
-        embedding_sum = tf.reduce_sum(inputs * broadcast_mask, axis=1)
-        mask_sum = tf.reduce_sum(broadcast_mask, axis=1)
-        mask_sum = tf.math.maximum(mask_sum, tf.constant([1e-9]))
-        return embedding_sum / mask_sum
-class WeightsSumOne(tf.keras.constraints.Constraint):
-    def __call__(self, w):
-        return tf.nn.softmax(w, axis=0)
-
-
-# In[ ]:
-
-
-tokenizer = transformers.AutoTokenizer.from_pretrained("microsoft/deberta-v3-large"
-)
-tokenizer.save_pretrained('./tokenizer/')
-
-cfg = transformers.AutoConfig.from_pretrained("microsoft/deberta-v3-large", output_hidden_states=True)
-cfg.hidden_dropout_prob = 0
-cfg.attention_probs_dropout_prob = 0
-cfg.save_pretrained('./tokenizer/')
-
-
-# In[ ]:
-
-
-def deberta_encode(texts, tokenizer=tokenizer):
-    input_ids = []
-    attention_mask = []
-    
-    for text in texts:
-        token = tokenizer(text, 
-                          add_special_tokens=True, 
-                          max_length=512, 
-                          return_attention_mask=True, 
-                          return_tensors="np", 
-                          truncation=True, 
-                          padding='max_length')
-        input_ids.append(token['input_ids'][0])
-        attention_mask.append(token['attention_mask'][0])
-    
-    return np.array(input_ids, dtype="int32"), np.array(attention_mask, dtype="int32")
-
-
-# In[ ]:
-
-
-MAX_LENGTH=512
-BATCH_SIZE=8
-
-
-# In[ ]:
-
-
-def get_model():
-    input_ids = tf.keras.layers.Input(
-        shape=(MAX_LENGTH,), dtype=tf.int32, name="input_ids"
-    )
-    
-    attention_masks = tf.keras.layers.Input(
-        shape=(MAX_LENGTH,), dtype=tf.int32, name="attention_masks"
-    )
-   
-    deberta_model = transformers.TFAutoModel.from_pretrained("microsoft/deberta-v3-large", config=cfg)
-    
-        
-    REINIT_LAYERS = 1
-    normal_initializer = tf.keras.initializers.GlorotUniform()
-    zeros_initializer = tf.keras.initializers.Zeros()
-    ones_initializer = tf.keras.initializers.Ones()
-
-#     print(f'\nRe-initializing encoder block:')
-    for encoder_block in deberta_model.deberta.encoder.layer[-REINIT_LAYERS:]:
-#         print(f'{encoder_block}')
-        for layer in encoder_block.submodules:
-            if isinstance(layer, tf.keras.layers.Dense):
-                layer.kernel.assign(normal_initializer(shape=layer.kernel.shape, dtype=layer.kernel.dtype))
-                if layer.bias is not None:
-                    layer.bias.assign(zeros_initializer(shape=layer.bias.shape, dtype=layer.bias.dtype))
-
-            elif isinstance(layer, tf.keras.layers.LayerNormalization):
-                layer.beta.assign(zeros_initializer(shape=layer.beta.shape, dtype=layer.beta.dtype))
-                layer.gamma.assign(ones_initializer(shape=layer.gamma.shape, dtype=layer.gamma.dtype))
-
-    deberta_output = deberta_model.deberta(
-        input_ids, attention_mask=attention_masks
-    )
-    hidden_states = deberta_output.hidden_states
-    
-    #WeightedLayerPool + MeanPool of the last 4 hidden states
-    stack_meanpool = tf.stack(
-        [MeanPool()(hidden_s, mask=attention_masks) for hidden_s in hidden_states[-4:]], 
-        axis=2)
-    
-    weighted_layer_pool = layers.Dense(1,
-                                       use_bias=False,
-                                       kernel_constraint=WeightsSumOne())(stack_meanpool)
-    
-    weighted_layer_pool = tf.squeeze(weighted_layer_pool, axis=-1)
-    output=layers.Dense(15,activation='linear')(weighted_layer_pool)
-    #x = layers.Dense(6, activation='linear')(x)
-    
-    #output = layers.Rescaling(scale=4.0, offset=1.0)(x)
-    model = tf.keras.Model(inputs=[input_ids, attention_masks], outputs=output)
-    
-    #Compile model with Layer-wise Learning Rate Decay
-    layer_list = [deberta_model.deberta.embeddings] + list(deberta_model.deberta.encoder.layer)
-    layer_list.reverse()
-    
-    INIT_LR = 1e-5
-    LLRDR = 0.9
-    LR_SCH_DECAY_STEPS = 1600
+import os
+import openai 
+from openai import OpenAI
+from dotenv import load_dotenv, find_dotenv
+
+%matplotlib inline
+import re
+import matplotlib.pyplot as plt
+
+sample_input = \
+"""
+Visitor: Heyyy
+Visitor: How are you this evening
+Agent: better now ;) call me
+Visitor: I am at work for now, be off around 10pm
+Visitor: Need some company
+Visitor: Are you independent honey
+Agent: well since you arent available at the moment ill just come out and say-these sites are bad news. \
+    did you know that most of the girls on here are here against their will? \
+    Most of them got dragged into this lifestyle by an abuser, \
+    oftentimes before they were of legal consenting age. isnt that sad?
+Agent: we are with some guys who are trying to spread awareness of the realities of this "industry".
+Agent: https://exoduscry.com/choice/
+Visitor: Thanks
+Agent: i encourage you to watch this video. it is jarring to think about how bad someone else's options must be to choose to be on these sites
+Visitor: Ooohhh
+Agent: selling their body to make ends meet or appease a pimp
+Visitor: That's really awful
+Agent: it is. you seem like the kind of guy who wouldnt wont to proliferate that kind of harmful lifestyle. am i right in thinking that?
+Visitor: Well iam just looking for attention
+Visitor: My marriage is not going well lol
+Agent: i know that it is hard to find ourselves lonely and without much alternative to meet that perceived need but \
+    its humbling to think that our needs can force someone else into such a dark place
+Agent: hey, thanks for sharing that my man. i know it can be hard
+Agent: marraige is the most humbling of relationships, isnt it?
+Visitor: She leaves with her friends n no time for me
+Agent: ive been there my guy. i know that it is alot easier to numb that loneliness for sure
+Visitor: I want to be faithful
+Agent: does your wife know how you feel when she chooses her friends instead of you?
+Visitor: I been drinking lately
+Visitor: Yes, she takes pills
+Agent: if so, i hope you are praying for her to realize the hurt she is causing and to seek change
+Visitor: She had surgery 4 yes ago n it's been hard for her n her addiction on pills
+Visitor: Yes for now i am looking for a female friend to talk n see what can we do for each other
+Agent: that is hard my man. physical pain is a huge obstacle in life for sure so i hear you
+Visitor: Well chat later. thanks
+Agent: have you considered pursuing other men who can encourage you instead of looking for the easy way out?
+Agent: what is your name my friend? i will be praying for you by name if you wouldnt mind sharing it
+Agent: well, i gotta run. watch that video i sent and i will definitely be praying for you. \
+    I hope you pray for yourself and for your wife - God can definitely intervene and cause complete change in the situation if He wills it. \
+    He is good and He hears you. You are loved by Him, brother. Good night
+"""
+
+sample_output = \
+"""
+Visitor: Heyyy
+[Greeting]
+Visitor: How are you this evening
+[Greeting]
+Agent: better now ;) call me
+[Openness]
+Visitor: I am at work for now, be off around 10pm
+[Interest]
+Visitor: Need some company
+[Interest]
+Visitor: Are you independent honey
+[Interest]
+Agent: well since you arent available at the moment ill just come out and say-these sites are bad news. \
+    did you know that most of the girls on here are here against their will? \
+    Most of them got dragged into this lifestyle by an abuser, \
+    oftentimes before they were of legal consenting age. isnt that sad?
+[Informative]
+Agent: we are with some guys who are trying to spread awareness of the realities of this "industry".
+[Informative]
+Agent: https://exoduscry.com/choice/
+[Informative]
+Visitor: Thanks
+[Acceptance]
+Agent: i encourage you to watch this video. it is jarring to think about how bad someone else's options must be to choose to be on these sites
+[Informative]
+Visitor: Ooohhh
+[Interest]
+Agent: selling their body to make ends meet or appease a pimp
+[Informative]
+Visitor: That's really awful
+[Remorse]
+Agent: it is. you seem like the kind of guy who wouldnt wont to proliferate that kind of harmful lifestyle. am i right in thinking that?
+[Accusatory]
+Visitor: Well iam just looking for attention
+[Anxious]
+Visitor: My marriage is not going well lol
+[Anxious]
+Agent: i know that it is hard to find ourselves lonely and without much alternative to meet that perceived need but \
+    its humbling to think that our needs can force someone else into such a dark place
+[Informative]
+Agent: hey, thanks for sharing that my man. i know it can be hard
+[Acceptance]
+Agent: marraige is the most humbling of relationships, isnt it?
+[Openness]
+Visitor: She leaves with her friends n no time for me
+[Annoyed]
+Agent: ive been there my guy. i know that it is alot easier to numb that loneliness for sure
+[Acceptance]
+Visitor: I want to be faithful
+[Acceptance]
+Agent: does your wife know how you feel when she chooses her friends instead of you?
+[Curiosity]
+Visitor: I been drinking lately
+[Anxious]
+Visitor: Yes, she takes pills
+[Anxious]
+Agent: if so, i hope you are praying for her to realize the hurt she is causing and to seek change
+[Interest]
+Visitor: She had surgery 4 yes ago n it's been hard for her n her addiction on pills
+[Anxious]
+Visitor: Yes for now i am looking for a female friend to talk n see what can we do for each other
+[Informative]
+Agent: that is hard my man. physical pain is a huge obstacle in life for sure so i hear you
+[Acceptance]
+Visitor: Well chat later. thanks
+[Openness]
+Agent: have you considered pursuing other men who can encourage you instead of looking for the easy way out?
+[Informative]
+Agent: what is your name my friend? i will be praying for you by name if you wouldnt mind sharing it
+[Openness]
+Agent: well, i gotta run. watch that video i sent and i will definitely be praying for you. \
+    I hope you pray for yourself and for your wife - God can definitely intervene and cause complete change in the situation if He wills it. \
+    He is good and He hears you. You are loved by Him, brother. Good night
+[Openness]
+
+Sentiment Flow Analysis on the Visitor's side:
+
+The Visitor begins the conversation with a friendly and casual tone, expressing a desire for company and showing interest in the Agent. \
+However, as the Agent provides information about the harsh realities of the commercial sex industry, the Visitor's sentiment shifts to acceptance of the information \
+and a sense of confusion and remorse about the situation.
+
+The Visitor then reveals personal issues, indicating anxiety and seeking attention due to marital problems. \
+The sentiment continues to be anxious as the Visitor discusses personal struggles with alcohol and his wife's pill addiction, \
+showing a need for companionship and support.
+
+Despite the heavy topics, the Visitor expresses a desire to remain faithful and shows interest in finding a friend, albeit with a hint of desperation. \
+The Visitor openly takes the Agent's information and the conversation flows smoothly as both the Visitor and the Agent \
+show openness toward each other.
+"""
+
+def get_completion(conversation, model="gpt-4-1106-preview"):
+
+    prompt = f"""
+    The EPIK Project is about mobilizing male allies \
+    to disrupt the commercial sex market, \
+    equipping them to combat the roots of exploitation \
+    and encouraging them to collaborate effectively \
+    with the wider anti-trafficking movement. \
+    You are an adept expert conversation sentiment analyzer. \
+    Your job is to analyze the conversation and provide a report \
+    based on the sentiment flow of the conversation on the visitor's \
+    perspective. Visitor indicates the potential buyer, and Agent indicates the volunteer from EPIK. \
+    The conversation is going to be given in the format:
     
-    lr_schedules = [tf.keras.optimizers.schedules.ExponentialDecay(
-        initial_learning_rate=INIT_LR * LLRDR ** i, 
-        decay_steps=LR_SCH_DECAY_STEPS, 
-        decay_rate=0.3) for i in range(len(layer_list))]
-    lr_schedule_head = tf.keras.optimizers.schedules.ExponentialDecay(
-        initial_learning_rate=1e-4, 
-        decay_steps=LR_SCH_DECAY_STEPS, 
-        decay_rate=0.3)
+    Visitor: <Visitor's message here>
+    Agent: <Agent's message here>
     
-    optimizers = [tf.keras.optimizers.Adam(learning_rate=lr_sch) for lr_sch in lr_schedules]
+    The actual conversation is delimited by triple backticks
+    ```{conversation}```
     
-    optimizers_and_layers = [(tf.keras.optimizers.Adam(learning_rate=lr_schedule_head), model.layers[-4:])] +\
-        list(zip(optimizers, layer_list))
+    Here is the list of sentiment labels you should use delimited by square brackets. \
+    ["Openness", "Anxious", "Confused", "Disapproval", "Remorse", "Accusatory", \
+    "Denial", "Obscene", "Uninterested", "Annoyed", "Informative", "Greeting", \
+    "Interest", "Curiosity", "Acceptance"]
     
-    optimizer = tfa.optimizers.MultiOptimizer(optimizers_and_layers)
+    Your output should look like:
+    ```
+    Speaker: <Speaker's message here>
+    [sentiment label]
+    ...
+    Speaker: <Speaker's message here>
+    [sentiment label]
+    ```
     
-    model.compile(optimizer=optimizer,
-                 loss='mse',
-                 metrics=[tf.keras.metrics.RootMeanSquaredError()],
-                 )
-    return model
-
-
-# In[ ]:
-
-
-tf.keras.backend.clear_session()
-model = get_model()
-model.load_weights('./best_model_fold2.h5')
-
-
-# In[ ]:
-
-
-
-
-
-# In[ ]:
-
-
-# map the integer labels to their original string representation
-label_mapping = {
-    0: 'Greeting',
-    1: 'Curiosity',
-    2: 'Interest',
-    3: 'Obscene',
-    4: 'Annoyed',
-    5: 'Openness',
-    6: 'Anxious',
-    7: 'Acceptance',
-    8: 'Uninterested',
-    9: 'Informative',
-    10: 'Accusatory',
-    11: 'Denial',
-    12: 'Confused',
-    13: 'Disapproval',
-    14: 'Remorse'
-}
-
-#label_strings = [label_mapping[label] for label in labels]
-
-#print(label_strings)
-
+    where Speaker can either be Visitor or Agent. Then, you should write your report on the sentiment flow \
+    on the Visitor's side below.
 
-# In[ ]:
+    Here is a sample input delimited by triple backticks
 
+    ```{sample_input}```
 
-def inference(texts):
-    prediction = model.predict(deberta_encode([texts]))
-    labels = np.argmax(prediction, axis=1)
-    label_strings = [label_mapping[label] for label in labels]
-    return label_strings[0]
+    Here is a same output that you should try to aim for delimited by sqaure brackets
 
-
-# # GPT
-
-# In[ ]:
-
-
-import openai
-import os
-import pandas as pd
-import gradio as gr
-
-
-# In[ ]:
-
-
-openai.organization = os.environ['org_id']
-openai.api_key = os.environ['openai_api']
-model_version = "gpt-3.5-turbo"
-model_token_limit = 10
-model_temperature = 0.1
-
-
-# In[ ]:
-
-
-def generatePrompt () :
-    labels = ["Openness", 
-    "Anxious",
-    "Confused",
-    "Disapproval",
-    "Remorse",
-    "Uninterested",
-    "Accusatory",
-    "Annoyed",
-    "Interest",
-    "Curiosity",
-    "Acceptance",
-    "Obscene",
-    "Denial",
-    "Informative",
-    "Greeting"]
-
-    formatted_labels = ', '.join(labels[:-1]) + ', or ' + labels[-1] + '.'
-
-    label_set = ["Openness", "Anxious", "Confused", "Disapproval", "Remorse", "Accusatory",
-          "Denial", "Obscene", "Uninterested", "Annoyed", "Informative", "Greeting",
-          "Interest", "Curiosity", "Acceptance"]
-
-    formatted_labels = ', '.join(label_set[:-1]) + ', or ' + label_set[-1] + '.\n'
-
-    # The basic task to assign GPT (in natural language)
-    base_task = "Classify the following text messages into one of the following categories using one word: " + formatted_labels
-    base_task += "Provide only a one word response. Use only the labels provided.\n"
-
-    return base_task
-
-
-# In[ ]:
-
-
-def predict(message):
+    [{sample_output}]
+    """
     
-    prompt = [{"role": "user", "content": generatePrompt () + "Text: "+ message}]
+    client = OpenAI()
     
-    response = openai.ChatCompletion.create(
-                    model=model_version,
-                    temperature=model_temperature,
-                    max_tokens=model_token_limit,
-                    messages=prompt
-                )
-        
-    return response["choices"][0]["message"]["content"]
-
-
-# # Update
-
-# In[ ]:
-
-
-model_version = "gpt-3.5-turbo"
-model_token_limit = 2000
-model_temperature = 0.1
+    messages = [{"role": "user", "content": prompt}]
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        temperature=0, # this is the degree of randomness of the model's output
+    )
 
+    analysis = response.choices[0].message.content
 
-# In[ ]:
+    def extract_conv_with_labels(analysis):
+        analysis = analysis.replace("\n", " ")
+        BETWEEN_BACKTICKS = "\\`\\`\\`(.*?)\\`\\`\\`"
+        match = re.search(BETWEEN_BACKTICKS, analysis)
+        if match:
+            conv_with_labels = match.group()[4:-4]
+        else:
+            return "OUTPUT IS IN WRONG FORMAT"
+        
+        # just reformatting it for better format
+        conv_with_labels = conv_with_labels.split('] ')
+        temp = [utterance + ']' for utterance in conv_with_labels[:-1]]
+        conv_with_labels = temp + [conv_with_labels[-1]]
+        return conv_with_labels
+
+    grouped_sentiments = {
+        'Acceptance': 3,
+        'Openness': 3,
+        'Interest': 2,
+        'Curiosity': 2,
+        'Informative': 1,
+        'Greeting': 0,
+        'None': 0,
+        'Uninterested': -1,
+        'Anxious': -2,
+        'Confused': -2,
+        'Annoyed': -2,
+        'Remorse': -2,
+        'Disapproval': -3,
+        'Accusatory': -3,
+        'Denial': -3,
+        'Obscene': -3
+    }
+
+
+    def sentiment_flow_plot(conv):
+        conv_with_labels = extract_conv_with_labels(analysis)
+        num_utterances = len(conv_with_labels)
+
+        visitor_Y = [''] * num_utterances
+        agent_Y = [''] * num_utterances
+
+        for i in range(num_utterances):
+            utterance = conv_with_labels[i]
+            match = re.search(r'\[(.*?)\]$', utterance)
+            if match:
+                label = match.group(1)
+            else:
+                print("OUTPUT IS IN WRONG FORMAT")
+                break
+            
+            if utterance.startswith('Visitor'):
+                visitor_Y[i] = label
+                if i == 0:
+                    agent_Y[i] = 'None'
+                else:
+                    agent_Y[i] = agent_Y[i-1]
+            elif utterance.startswith('Agent'):
+                agent_Y[i] = label
+                if i == 0:
+                    visitor_Y[i] = 'None'
+                else:
+                    visitor_Y[i] = visitor_Y[i-1]
+
+        X = range(1,num_utterances+1)
+        visitor_Y_converted = [grouped_sentiments[visitor_Y[i]] for i in range(num_utterances)]
+        agent_Y_converted = [grouped_sentiments[agent_Y[i]] for i in range(num_utterances)]
+
+        plt.style.use('seaborn')
+
+        fig, ax = plt.subplots()
+
+
+        ax.plot(X, visitor_Y_converted, label='Visitor', color='blue', marker='o')
+        ax.plot(X, agent_Y_converted, label='Agent', color='green', marker='o')
+
+        plt.yticks(ticks=[-3,-2,-1,0,1,2,3], 
+                labels=['Disapproval/Accusatory/Denial/Obscene', 'Anxious/Confused/Annoyed/Remorse',
+                        'Uninterested', 'Greeting/None', 'Informative', 'Interest/Curiosity', 'Acceptance/Openness'])
+        
+        for label in ax.get_yticklabels():
+            label.set_rotation(45)
 
+        plt.xlabel('Number of utterances')
+        plt.ylabel('Sentiments')
+        plt.title('Sentiment Flow Plot')
 
-def revision(message):
-    base_prompt = "Here is a conversation between a Caller and a Volunteer. The Volunteer is trying to be as non-accusatory as possible but also wants to get as much information about the caller as possible. What should the volunteer say next in this exchange? Proved 3 possible responses."
+        plt.close(fig)
 
-    prompt = [{"role": "user", "content": base_prompt + message}]
+        return fig
     
-    response = openai.ChatCompletion.create(
-                    model=model_version,
-                    temperature=model_temperature,
-                    max_tokens=model_token_limit,
-                    messages=prompt
-                )
+    fig = sentiment_flow_plot(analysis)
 
-    return response["choices"][0]["message"]["content"]
-
-
-# In[ ]:
+    return response.choices[0].message.content, fig
 
+def set_key(key):
+    with open("_.env", "w") as file:
+        file.write(f"OPENAI_API_KEY={key}")
+        
+    load_dotenv(find_dotenv("_.env"), override=True)
+    return
 
 import gradio as gr
 
-def combine(a):
-    return a + "hello"
-
-
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("## DeBERTa Sentiment Analysis")
-    gr.Markdown("This is a custom DeBERTa model architecture for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br/>The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.")
-
-    txt = gr.Textbox(label="Input", lines=2)
-    txt_1 = gr.Textbox(value="", label="Output")
+with gr.Blocks() as gpt_analysis:
+    gr.Markdown("## Conversation Analysis")
+    gr.Markdown(
+        "This is a custom GPT model designed to provide \
+        a report on overall sentiment flow of the conversation on the \
+        volunteer's perspective.<br /> Click on them and submit them to the model to see how it works.")
+    api_key = gr.Textbox(label="Key", lines=1)
+    btn_key = gr.Button(value="Submit Key")
+    btn_key.click(set_key, inputs=api_key)
+    conversation = gr.Textbox(label="Input", lines=2)
     btn = gr.Button(value="Submit")
-    btn.click(inference, inputs=txt, outputs= txt_1)
-
-    demoExample = [
-        "Hello, how are you?",
-        "I am so happy to be here!",
-        "i don't have time for u"
-    ]
-
-    gr.Markdown("## Text Examples")
-    gr.Examples(
-        demoExample,
-        txt,
-        txt_1,
-        inference
-    )
-
-with gr.Blocks() as gptdemo:
-
-    gr.Markdown("## GPT Sentiment Analysis")
-    gr.Markdown("This a custom GPT model for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.Please note that the input may be collected by service providers.")
-    txt = gr.Textbox(label="Input", lines=2)
-    txt_1 = gr.Textbox(value="", label="Output")
-    btn = gr.Button(value="Submit")
-    btn.click(predict, inputs=txt, outputs= txt_1)
-
-    gptExample = [
-        "Hello, how are you?",
-        "Are you busy at the moment?",
-        "I'm doing real good"
-    ]
-
-    gr.Markdown("## Text Examples")
-    gr.Examples(
-        gptExample,
-        txt,
-        txt_1,
-        predict
-    )
-
-
-with gr.Blocks() as revisiondemo:
-    gr.Markdown("## Conversation Revision")
-    gr.Markdown("This is a custom GPT model designed to generate possible response texts based on previous contexts. You can input a conversation between a caller and a volunteer, and the model will provide three possible responses based on the input. <br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works. Please note that the input may be collected by service providers.")
-    txt = gr.Textbox(label="Input", lines=2)
-    txt_1 = gr.Textbox(value="", label="Output",lines=4)
-    btn = gr.Button(value="Submit")
-    btn.click(revision, inputs=txt, outputs= txt_1)
-
-    revisionExample = ["Caller: sup\nVolunteer: Hey, how's it going?\nCaller: not very well, actually\nVolunteer: What's the matter?\nCaller: it's my wife, don't worry about it"]
-
-    with gr.Column():
-        gr.Markdown("## Text Examples")
-        gr.Examples(
-            revisionExample,
-            [txt],
-            txt_1,
-            revision
-        )
-
-
-
-
-gr.TabbedInterface([demo, gptdemo,revisiondemo], ["Model", "GPT","Text Revision"]
-).launch(inline=False)
+    with gr.Row():
+        output_box = gr.Textbox(value="", label="Output",lines=4)
+        plot_box = gr.Plot(label="Analysis Plot")
+        
+    btn.click(get_completion, inputs=conversation, outputs=[output_box, plot_box])
 
+gr.TabbedInterface([gpt_analysis], ["GPT Anlysis"]).launch(inline=False)

app_spring2023.ipynb

@@ -0,0 +1,483 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_addons as tfa\n",
+    "from tensorflow.keras import layers\n",
+    "import transformers\n",
+    "import sentencepiece as spm\n",
+    "#show the version of the package imported with text instructions\\\n",
+    "print(\"Tensorflow version: \", tf.__version__)\n",
+    "print(\"Tensorflow Addons version: \", tfa.__version__)\n",
+    "print(\"Transformers version: \", transformers.__version__)\n",
+    "print(\"Sentencepiece version: \", spm.__version__)\n",
+    "print(\"Numpy version: \", np.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MeanPool(tf.keras.layers.Layer):\n",
+    "    def call(self, inputs, mask=None):\n",
+    "        broadcast_mask = tf.expand_dims(tf.cast(mask, \"float32\"), -1)\n",
+    "        embedding_sum = tf.reduce_sum(inputs * broadcast_mask, axis=1)\n",
+    "        mask_sum = tf.reduce_sum(broadcast_mask, axis=1)\n",
+    "        mask_sum = tf.math.maximum(mask_sum, tf.constant([1e-9]))\n",
+    "        return embedding_sum / mask_sum\n",
+    "class WeightsSumOne(tf.keras.constraints.Constraint):\n",
+    "    def __call__(self, w):\n",
+    "        return tf.nn.softmax(w, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = transformers.AutoTokenizer.from_pretrained(\"microsoft/deberta-v3-large\"\n",
+    ")\n",
+    "tokenizer.save_pretrained('./tokenizer/')\n",
+    "\n",
+    "cfg = transformers.AutoConfig.from_pretrained(\"microsoft/deberta-v3-large\", output_hidden_states=True)\n",
+    "cfg.hidden_dropout_prob = 0\n",
+    "cfg.attention_probs_dropout_prob = 0\n",
+    "cfg.save_pretrained('./tokenizer/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def deberta_encode(texts, tokenizer=tokenizer):\n",
+    "    input_ids = []\n",
+    "    attention_mask = []\n",
+    "    \n",
+    "    for text in texts:\n",
+    "        token = tokenizer(text, \n",
+    "                          add_special_tokens=True, \n",
+    "                          max_length=512, \n",
+    "                          return_attention_mask=True, \n",
+    "                          return_tensors=\"np\", \n",
+    "                          truncation=True, \n",
+    "                          padding='max_length')\n",
+    "        input_ids.append(token['input_ids'][0])\n",
+    "        attention_mask.append(token['attention_mask'][0])\n",
+    "    \n",
+    "    return np.array(input_ids, dtype=\"int32\"), np.array(attention_mask, dtype=\"int32\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MAX_LENGTH=512\n",
+    "BATCH_SIZE=8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_model():\n",
+    "    input_ids = tf.keras.layers.Input(\n",
+    "        shape=(MAX_LENGTH,), dtype=tf.int32, name=\"input_ids\"\n",
+    "    )\n",
+    "    \n",
+    "    attention_masks = tf.keras.layers.Input(\n",
+    "        shape=(MAX_LENGTH,), dtype=tf.int32, name=\"attention_masks\"\n",
+    "    )\n",
+    "   \n",
+    "    deberta_model = transformers.TFAutoModel.from_pretrained(\"microsoft/deberta-v3-large\", config=cfg)\n",
+    "    \n",
+    "        \n",
+    "    REINIT_LAYERS = 1\n",
+    "    normal_initializer = tf.keras.initializers.GlorotUniform()\n",
+    "    zeros_initializer = tf.keras.initializers.Zeros()\n",
+    "    ones_initializer = tf.keras.initializers.Ones()\n",
+    "\n",
+    "#     print(f'\\nRe-initializing encoder block:')\n",
+    "    for encoder_block in deberta_model.deberta.encoder.layer[-REINIT_LAYERS:]:\n",
+    "#         print(f'{encoder_block}')\n",
+    "        for layer in encoder_block.submodules:\n",
+    "            if isinstance(layer, tf.keras.layers.Dense):\n",
+    "                layer.kernel.assign(normal_initializer(shape=layer.kernel.shape, dtype=layer.kernel.dtype))\n",
+    "                if layer.bias is not None:\n",
+    "                    layer.bias.assign(zeros_initializer(shape=layer.bias.shape, dtype=layer.bias.dtype))\n",
+    "\n",
+    "            elif isinstance(layer, tf.keras.layers.LayerNormalization):\n",
+    "                layer.beta.assign(zeros_initializer(shape=layer.beta.shape, dtype=layer.beta.dtype))\n",
+    "                layer.gamma.assign(ones_initializer(shape=layer.gamma.shape, dtype=layer.gamma.dtype))\n",
+    "\n",
+    "    deberta_output = deberta_model.deberta(\n",
+    "        input_ids, attention_mask=attention_masks\n",
+    "    )\n",
+    "    hidden_states = deberta_output.hidden_states\n",
+    "    \n",
+    "    #WeightedLayerPool + MeanPool of the last 4 hidden states\n",
+    "    stack_meanpool = tf.stack(\n",
+    "        [MeanPool()(hidden_s, mask=attention_masks) for hidden_s in hidden_states[-4:]], \n",
+    "        axis=2)\n",
+    "    \n",
+    "    weighted_layer_pool = layers.Dense(1,\n",
+    "                                       use_bias=False,\n",
+    "                                       kernel_constraint=WeightsSumOne())(stack_meanpool)\n",
+    "    \n",
+    "    weighted_layer_pool = tf.squeeze(weighted_layer_pool, axis=-1)\n",
+    "    output=layers.Dense(15,activation='linear')(weighted_layer_pool)\n",
+    "    #x = layers.Dense(6, activation='linear')(x)\n",
+    "    \n",
+    "    #output = layers.Rescaling(scale=4.0, offset=1.0)(x)\n",
+    "    model = tf.keras.Model(inputs=[input_ids, attention_masks], outputs=output)\n",
+    "    \n",
+    "    #Compile model with Layer-wise Learning Rate Decay\n",
+    "    layer_list = [deberta_model.deberta.embeddings] + list(deberta_model.deberta.encoder.layer)\n",
+    "    layer_list.reverse()\n",
+    "    \n",
+    "    INIT_LR = 1e-5\n",
+    "    LLRDR = 0.9\n",
+    "    LR_SCH_DECAY_STEPS = 1600\n",
+    "    \n",
+    "    lr_schedules = [tf.keras.optimizers.schedules.ExponentialDecay(\n",
+    "        initial_learning_rate=INIT_LR * LLRDR ** i, \n",
+    "        decay_steps=LR_SCH_DECAY_STEPS, \n",
+    "        decay_rate=0.3) for i in range(len(layer_list))]\n",
+    "    lr_schedule_head = tf.keras.optimizers.schedules.ExponentialDecay(\n",
+    "        initial_learning_rate=1e-4, \n",
+    "        decay_steps=LR_SCH_DECAY_STEPS, \n",
+    "        decay_rate=0.3)\n",
+    "    \n",
+    "    optimizers = [tf.keras.optimizers.Adam(learning_rate=lr_sch) for lr_sch in lr_schedules]\n",
+    "    \n",
+    "    optimizers_and_layers = [(tf.keras.optimizers.Adam(learning_rate=lr_schedule_head), model.layers[-4:])] +\\\n",
+    "        list(zip(optimizers, layer_list))\n",
+    "    \n",
+    "    optimizer = tfa.optimizers.MultiOptimizer(optimizers_and_layers)\n",
+    "    \n",
+    "    model.compile(optimizer=optimizer,\n",
+    "                 loss='mse',\n",
+    "                 metrics=[tf.keras.metrics.RootMeanSquaredError()],\n",
+    "                 )\n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tf.keras.backend.clear_session()\n",
+    "model = get_model()\n",
+    "model.load_weights('./best_model_fold2.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# map the integer labels to their original string representation\n",
+    "label_mapping = {\n",
+    "    0: 'Greeting',\n",
+    "    1: 'Curiosity',\n",
+    "    2: 'Interest',\n",
+    "    3: 'Obscene',\n",
+    "    4: 'Annoyed',\n",
+    "    5: 'Openness',\n",
+    "    6: 'Anxious',\n",
+    "    7: 'Acceptance',\n",
+    "    8: 'Uninterested',\n",
+    "    9: 'Informative',\n",
+    "    10: 'Accusatory',\n",
+    "    11: 'Denial',\n",
+    "    12: 'Confused',\n",
+    "    13: 'Disapproval',\n",
+    "    14: 'Remorse'\n",
+    "}\n",
+    "\n",
+    "#label_strings = [label_mapping[label] for label in labels]\n",
+    "\n",
+    "#print(label_strings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def inference(texts):\n",
+    "    prediction = model.predict(deberta_encode([texts]))\n",
+    "    labels = np.argmax(prediction, axis=1)\n",
+    "    label_strings = [label_mapping[label] for label in labels]\n",
+    "    return label_strings[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GPT"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import openai\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import gradio as gr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.organization = os.environ['org_id']\n",
+    "openai.api_key = os.environ['openai_api']\n",
+    "model_version = \"gpt-3.5-turbo\"\n",
+    "model_token_limit = 10\n",
+    "model_temperature = 0.1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generatePrompt () :\n",
+    "    labels = [\"Openness\", \n",
+    "    \"Anxious\",\n",
+    "    \"Confused\",\n",
+    "    \"Disapproval\",\n",
+    "    \"Remorse\",\n",
+    "    \"Uninterested\",\n",
+    "    \"Accusatory\",\n",
+    "    \"Annoyed\",\n",
+    "    \"Interest\",\n",
+    "    \"Curiosity\",\n",
+    "    \"Acceptance\",\n",
+    "    \"Obscene\",\n",
+    "    \"Denial\",\n",
+    "    \"Informative\",\n",
+    "    \"Greeting\"]\n",
+    "\n",
+    "    formatted_labels = ', '.join(labels[:-1]) + ', or ' + labels[-1] + '.'\n",
+    "\n",
+    "    label_set = [\"Openness\", \"Anxious\", \"Confused\", \"Disapproval\", \"Remorse\", \"Accusatory\",\n",
+    "          \"Denial\", \"Obscene\", \"Uninterested\", \"Annoyed\", \"Informative\", \"Greeting\",\n",
+    "          \"Interest\", \"Curiosity\", \"Acceptance\"]\n",
+    "\n",
+    "    formatted_labels = ', '.join(label_set[:-1]) + ', or ' + label_set[-1] + '.\\n'\n",
+    "\n",
+    "    # The basic task to assign GPT (in natural language)\n",
+    "    base_task = \"Classify the following text messages into one of the following categories using one word: \" + formatted_labels\n",
+    "    base_task += \"Provide only a one word response. Use only the labels provided.\\n\"\n",
+    "\n",
+    "    return base_task"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(message):\n",
+    "    \n",
+    "    prompt = [{\"role\": \"user\", \"content\": generatePrompt () + \"Text: \"+ message}]\n",
+    "    \n",
+    "    response = openai.ChatCompletion.create(\n",
+    "                    model=model_version,\n",
+    "                    temperature=model_temperature,\n",
+    "                    max_tokens=model_token_limit,\n",
+    "                    messages=prompt\n",
+    "                )\n",
+    "        \n",
+    "    return response[\"choices\"][0][\"message\"][\"content\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Update"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_version = \"gpt-3.5-turbo\"\n",
+    "model_token_limit = 2000\n",
+    "model_temperature = 0.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def revision(message):\n",
+    "    base_prompt = \"Here is a conversation between a Caller and a Volunteer. The Volunteer is trying to be as non-accusatory as possible but also wants to get as much information about the caller as possible. What should the volunteer say next in this exchange? Proved 3 possible responses.\"\n",
+    "\n",
+    "    prompt = [{\"role\": \"user\", \"content\": base_prompt + message}]\n",
+    "    \n",
+    "    response = openai.ChatCompletion.create(\n",
+    "                    model=model_version,\n",
+    "                    temperature=model_temperature,\n",
+    "                    max_tokens=model_token_limit,\n",
+    "                    messages=prompt\n",
+    "                )\n",
+    "\n",
+    "    return response[\"choices\"][0][\"message\"][\"content\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "def combine(a):\n",
+    "    return a + \"hello\"\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "with gr.Blocks() as demo:\n",
+    "    gr.Markdown(\"## DeBERTa Sentiment Analysis\")\n",
+    "    gr.Markdown(\"This is a custom DeBERTa model architecture for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br/>The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.\")\n",
+    "\n",
+    "    txt = gr.Textbox(label=\"Input\", lines=2)\n",
+    "    txt_1 = gr.Textbox(value=\"\", label=\"Output\")\n",
+    "    btn = gr.Button(value=\"Submit\")\n",
+    "    btn.click(inference, inputs=txt, outputs= txt_1)\n",
+    "\n",
+    "    demoExample = [\n",
+    "        \"Hello, how are you?\",\n",
+    "        \"I am so happy to be here!\",\n",
+    "        \"i don't have time for u\"\n",
+    "    ]\n",
+    "\n",
+    "    gr.Markdown(\"## Text Examples\")\n",
+    "    gr.Examples(\n",
+    "        demoExample,\n",
+    "        txt,\n",
+    "        txt_1,\n",
+    "        inference\n",
+    "    )\n",
+    "\n",
+    "with gr.Blocks() as gptdemo:\n",
+    "\n",
+    "    gr.Markdown(\"## GPT Sentiment Analysis\")\n",
+    "    gr.Markdown(\"This a custom GPT model for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.Please note that the input may be collected by service providers.\")\n",
+    "    txt = gr.Textbox(label=\"Input\", lines=2)\n",
+    "    txt_1 = gr.Textbox(value=\"\", label=\"Output\")\n",
+    "    btn = gr.Button(value=\"Submit\")\n",
+    "    btn.click(predict, inputs=txt, outputs= txt_1)\n",
+    "\n",
+    "    gptExample = [\n",
+    "        \"Hello, how are you?\",\n",
+    "        \"Are you busy at the moment?\",\n",
+    "        \"I'm doing real good\"\n",
+    "    ]\n",
+    "\n",
+    "    gr.Markdown(\"## Text Examples\")\n",
+    "    gr.Examples(\n",
+    "        gptExample,\n",
+    "        txt,\n",
+    "        txt_1,\n",
+    "        predict\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "with gr.Blocks() as revisiondemo:\n",
+    "    gr.Markdown(\"## Conversation Revision\")\n",
+    "    gr.Markdown(\"This is a custom GPT model designed to generate possible response texts based on previous contexts. You can input a conversation between a caller and a volunteer, and the model will provide three possible responses based on the input. <br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works. Please note that the input may be collected by service providers.\")\n",
+    "    txt = gr.Textbox(label=\"Input\", lines=2)\n",
+    "    txt_1 = gr.Textbox(value=\"\", label=\"Output\",lines=4)\n",
+    "    btn = gr.Button(value=\"Submit\")\n",
+    "    btn.click(revision, inputs=txt, outputs= txt_1)\n",
+    "\n",
+    "    revisionExample = [\"Caller: sup\\nVolunteer: Hey, how's it going?\\nCaller: not very well, actually\\nVolunteer: What's the matter?\\nCaller: it's my wife, don't worry about it\"]\n",
+    "\n",
+    "    with gr.Column():\n",
+    "        gr.Markdown(\"## Text Examples\")\n",
+    "        gr.Examples(\n",
+    "            revisionExample,\n",
+    "            [txt],\n",
+    "            txt_1,\n",
+    "            revision\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "gr.TabbedInterface([demo, gptdemo,revisiondemo], [\"Model\", \"GPT\",\"Text Revision\"]\n",
+    ").launch(inline=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "76d9096663e4677afe736ff46b3dcdaff586dfdb471519f50b872333a086db78"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app_spring2023.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[ ]:
+
+
+import numpy as np
+import tensorflow as tf
+import tensorflow_addons as tfa
+from tensorflow.keras import layers
+import transformers
+import sentencepiece as spm
+#show the version of the package imported with text instructions\
+print("Tensorflow version: ", tf.__version__)
+print("Tensorflow Addons version: ", tfa.__version__)
+print("Transformers version: ", transformers.__version__)
+print("Sentencepiece version: ", spm.__version__)
+print("Numpy version: ", np.__version__)
+
+
+# In[ ]:
+
+
+class MeanPool(tf.keras.layers.Layer):
+    def call(self, inputs, mask=None):
+        broadcast_mask = tf.expand_dims(tf.cast(mask, "float32"), -1)
+        embedding_sum = tf.reduce_sum(inputs * broadcast_mask, axis=1)
+        mask_sum = tf.reduce_sum(broadcast_mask, axis=1)
+        mask_sum = tf.math.maximum(mask_sum, tf.constant([1e-9]))
+        return embedding_sum / mask_sum
+class WeightsSumOne(tf.keras.constraints.Constraint):
+    def __call__(self, w):
+        return tf.nn.softmax(w, axis=0)
+
+
+# In[ ]:
+
+
+tokenizer = transformers.AutoTokenizer.from_pretrained("microsoft/deberta-v3-large"
+)
+tokenizer.save_pretrained('./tokenizer/')
+
+cfg = transformers.AutoConfig.from_pretrained("microsoft/deberta-v3-large", output_hidden_states=True)
+cfg.hidden_dropout_prob = 0
+cfg.attention_probs_dropout_prob = 0
+cfg.save_pretrained('./tokenizer/')
+
+
+# In[ ]:
+
+
+def deberta_encode(texts, tokenizer=tokenizer):
+    input_ids = []
+    attention_mask = []
+    
+    for text in texts:
+        token = tokenizer(text, 
+                          add_special_tokens=True, 
+                          max_length=512, 
+                          return_attention_mask=True, 
+                          return_tensors="np", 
+                          truncation=True, 
+                          padding='max_length')
+        input_ids.append(token['input_ids'][0])
+        attention_mask.append(token['attention_mask'][0])
+    
+    return np.array(input_ids, dtype="int32"), np.array(attention_mask, dtype="int32")
+
+
+# In[ ]:
+
+
+MAX_LENGTH=512
+BATCH_SIZE=8
+
+
+# In[ ]:
+
+
+def get_model():
+    input_ids = tf.keras.layers.Input(
+        shape=(MAX_LENGTH,), dtype=tf.int32, name="input_ids"
+    )
+    
+    attention_masks = tf.keras.layers.Input(
+        shape=(MAX_LENGTH,), dtype=tf.int32, name="attention_masks"
+    )
+   
+    deberta_model = transformers.TFAutoModel.from_pretrained("microsoft/deberta-v3-large", config=cfg)
+    
+        
+    REINIT_LAYERS = 1
+    normal_initializer = tf.keras.initializers.GlorotUniform()
+    zeros_initializer = tf.keras.initializers.Zeros()
+    ones_initializer = tf.keras.initializers.Ones()
+
+#     print(f'\nRe-initializing encoder block:')
+    for encoder_block in deberta_model.deberta.encoder.layer[-REINIT_LAYERS:]:
+#         print(f'{encoder_block}')
+        for layer in encoder_block.submodules:
+            if isinstance(layer, tf.keras.layers.Dense):
+                layer.kernel.assign(normal_initializer(shape=layer.kernel.shape, dtype=layer.kernel.dtype))
+                if layer.bias is not None:
+                    layer.bias.assign(zeros_initializer(shape=layer.bias.shape, dtype=layer.bias.dtype))
+
+            elif isinstance(layer, tf.keras.layers.LayerNormalization):
+                layer.beta.assign(zeros_initializer(shape=layer.beta.shape, dtype=layer.beta.dtype))
+                layer.gamma.assign(ones_initializer(shape=layer.gamma.shape, dtype=layer.gamma.dtype))
+
+    deberta_output = deberta_model.deberta(
+        input_ids, attention_mask=attention_masks
+    )
+    hidden_states = deberta_output.hidden_states
+    
+    #WeightedLayerPool + MeanPool of the last 4 hidden states
+    stack_meanpool = tf.stack(
+        [MeanPool()(hidden_s, mask=attention_masks) for hidden_s in hidden_states[-4:]], 
+        axis=2)
+    
+    weighted_layer_pool = layers.Dense(1,
+                                       use_bias=False,
+                                       kernel_constraint=WeightsSumOne())(stack_meanpool)
+    
+    weighted_layer_pool = tf.squeeze(weighted_layer_pool, axis=-1)
+    output=layers.Dense(15,activation='linear')(weighted_layer_pool)
+    #x = layers.Dense(6, activation='linear')(x)
+    
+    #output = layers.Rescaling(scale=4.0, offset=1.0)(x)
+    model = tf.keras.Model(inputs=[input_ids, attention_masks], outputs=output)
+    
+    #Compile model with Layer-wise Learning Rate Decay
+    layer_list = [deberta_model.deberta.embeddings] + list(deberta_model.deberta.encoder.layer)
+    layer_list.reverse()
+    
+    INIT_LR = 1e-5
+    LLRDR = 0.9
+    LR_SCH_DECAY_STEPS = 1600
+    
+    lr_schedules = [tf.keras.optimizers.schedules.ExponentialDecay(
+        initial_learning_rate=INIT_LR * LLRDR ** i, 
+        decay_steps=LR_SCH_DECAY_STEPS, 
+        decay_rate=0.3) for i in range(len(layer_list))]
+    lr_schedule_head = tf.keras.optimizers.schedules.ExponentialDecay(
+        initial_learning_rate=1e-4, 
+        decay_steps=LR_SCH_DECAY_STEPS, 
+        decay_rate=0.3)
+    
+    optimizers = [tf.keras.optimizers.Adam(learning_rate=lr_sch) for lr_sch in lr_schedules]
+    
+    optimizers_and_layers = [(tf.keras.optimizers.Adam(learning_rate=lr_schedule_head), model.layers[-4:])] +\
+        list(zip(optimizers, layer_list))
+    
+    optimizer = tfa.optimizers.MultiOptimizer(optimizers_and_layers)
+    
+    model.compile(optimizer=optimizer,
+                 loss='mse',
+                 metrics=[tf.keras.metrics.RootMeanSquaredError()],
+                 )
+    return model
+
+
+# In[ ]:
+
+
+tf.keras.backend.clear_session()
+model = get_model()
+model.load_weights('./best_model_fold2.h5')
+
+
+# In[ ]:
+
+
+
+
+
+# In[ ]:
+
+
+# map the integer labels to their original string representation
+label_mapping = {
+    0: 'Greeting',
+    1: 'Curiosity',
+    2: 'Interest',
+    3: 'Obscene',
+    4: 'Annoyed',
+    5: 'Openness',
+    6: 'Anxious',
+    7: 'Acceptance',
+    8: 'Uninterested',
+    9: 'Informative',
+    10: 'Accusatory',
+    11: 'Denial',
+    12: 'Confused',
+    13: 'Disapproval',
+    14: 'Remorse'
+}
+
+#label_strings = [label_mapping[label] for label in labels]
+
+#print(label_strings)
+
+
+# In[ ]:
+
+
+def inference(texts):
+    prediction = model.predict(deberta_encode([texts]))
+    labels = np.argmax(prediction, axis=1)
+    label_strings = [label_mapping[label] for label in labels]
+    return label_strings[0]
+
+
+# # GPT
+
+# In[ ]:
+
+
+import openai
+import os
+import pandas as pd
+import gradio as gr
+
+
+# In[ ]:
+
+
+openai.organization = os.environ['org_id']
+openai.api_key = os.environ['openai_api']
+model_version = "gpt-3.5-turbo"
+model_token_limit = 10
+model_temperature = 0.1
+
+
+# In[ ]:
+
+
+def generatePrompt () :
+    labels = ["Openness", 
+    "Anxious",
+    "Confused",
+    "Disapproval",
+    "Remorse",
+    "Uninterested",
+    "Accusatory",
+    "Annoyed",
+    "Interest",
+    "Curiosity",
+    "Acceptance",
+    "Obscene",
+    "Denial",
+    "Informative",
+    "Greeting"]
+
+    formatted_labels = ', '.join(labels[:-1]) + ', or ' + labels[-1] + '.'
+
+    label_set = ["Openness", "Anxious", "Confused", "Disapproval", "Remorse", "Accusatory",
+          "Denial", "Obscene", "Uninterested", "Annoyed", "Informative", "Greeting",
+          "Interest", "Curiosity", "Acceptance"]
+
+    formatted_labels = ', '.join(label_set[:-1]) + ', or ' + label_set[-1] + '.\n'
+
+    # The basic task to assign GPT (in natural language)
+    base_task = "Classify the following text messages into one of the following categories using one word: " + formatted_labels
+    base_task += "Provide only a one word response. Use only the labels provided.\n"
+
+    return base_task
+
+
+# In[ ]:
+
+
+def predict(message):
+    
+    prompt = [{"role": "user", "content": generatePrompt () + "Text: "+ message}]
+    
+    response = openai.ChatCompletion.create(
+                    model=model_version,
+                    temperature=model_temperature,
+                    max_tokens=model_token_limit,
+                    messages=prompt
+                )
+        
+    return response["choices"][0]["message"]["content"]
+
+
+# # Update
+
+# In[ ]:
+
+
+model_version = "gpt-3.5-turbo"
+model_token_limit = 2000
+model_temperature = 0.1
+
+
+# In[ ]:
+
+
+def revision(message):
+    base_prompt = "Here is a conversation between a Caller and a Volunteer. The Volunteer is trying to be as non-accusatory as possible but also wants to get as much information about the caller as possible. What should the volunteer say next in this exchange? Proved 3 possible responses."
+
+    prompt = [{"role": "user", "content": base_prompt + message}]
+    
+    response = openai.ChatCompletion.create(
+                    model=model_version,
+                    temperature=model_temperature,
+                    max_tokens=model_token_limit,
+                    messages=prompt
+                )
+
+    return response["choices"][0]["message"]["content"]
+
+
+# In[ ]:
+
+
+import gradio as gr
+
+def combine(a):
+    return a + "hello"
+
+
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("## DeBERTa Sentiment Analysis")
+    gr.Markdown("This is a custom DeBERTa model architecture for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br/>The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.")
+
+    txt = gr.Textbox(label="Input", lines=2)
+    txt_1 = gr.Textbox(value="", label="Output")
+    btn = gr.Button(value="Submit")
+    btn.click(inference, inputs=txt, outputs= txt_1)
+
+    demoExample = [
+        "Hello, how are you?",
+        "I am so happy to be here!",
+        "i don't have time for u"
+    ]
+
+    gr.Markdown("## Text Examples")
+    gr.Examples(
+        demoExample,
+        txt,
+        txt_1,
+        inference
+    )
+
+with gr.Blocks() as gptdemo:
+
+    gr.Markdown("## GPT Sentiment Analysis")
+    gr.Markdown("This a custom GPT model for sentiment analysis with 15 labels: Openness, Anxiety, Confusion, Disapproval, Remorse, Accusation, Denial, Obscenity, Disinterest, Annoyance, Information, Greeting, Interest, Curiosity, or Acceptance.<br />Please enter your sentence(s) in the input box below and click the Submit button. The model will then process the input and provide the sentiment in one of the labels.<br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works.Please note that the input may be collected by service providers.")
+    txt = gr.Textbox(label="Input", lines=2)
+    txt_1 = gr.Textbox(value="", label="Output")
+    btn = gr.Button(value="Submit")
+    btn.click(predict, inputs=txt, outputs= txt_1)
+
+    gptExample = [
+        "Hello, how are you?",
+        "Are you busy at the moment?",
+        "I'm doing real good"
+    ]
+
+    gr.Markdown("## Text Examples")
+    gr.Examples(
+        gptExample,
+        txt,
+        txt_1,
+        predict
+    )
+
+
+with gr.Blocks() as revisiondemo:
+    gr.Markdown("## Conversation Revision")
+    gr.Markdown("This is a custom GPT model designed to generate possible response texts based on previous contexts. You can input a conversation between a caller and a volunteer, and the model will provide three possible responses based on the input. <br />The Test Example section below provides some input examples. Click on them and submit them to the model to see how it works. Please note that the input may be collected by service providers.")
+    txt = gr.Textbox(label="Input", lines=2)
+    txt_1 = gr.Textbox(value="", label="Output",lines=4)
+    btn = gr.Button(value="Submit")
+    btn.click(revision, inputs=txt, outputs= txt_1)
+
+    revisionExample = ["Caller: sup\nVolunteer: Hey, how's it going?\nCaller: not very well, actually\nVolunteer: What's the matter?\nCaller: it's my wife, don't worry about it"]
+
+    with gr.Column():
+        gr.Markdown("## Text Examples")
+        gr.Examples(
+            revisionExample,
+            [txt],
+            txt_1,
+            revision
+        )
+
+
+
+
+gr.TabbedInterface([demo, gptdemo,revisiondemo], ["Model", "GPT","Text Revision"]
+).launch(inline=False)
+