Duplicate from ferdmartin/GradApplicationDocsApp

.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

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor="#6eb52f"
+backgroundColor="#f0f0f5"
+secondaryBackgroundColor="#e0e0ef"
+textColor="#262730"
+font="monospace"
+
+[client]
+showErrorDetails = false

README.md

@@ -0,0 +1,15 @@
+---
+title: GradApplicationDocsApp
+emoji: 💻
+colorFrom: purple
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.19.0
+app_file: app.py
+pinned: false
+fullWidth: true
+license: mit
+duplicated_from: ferdmartin/GradApplicationDocsApp
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,214 @@
+def main():
+    """
+    Creates a Streamlit web app that classifies a given body of text as either human-made or AI-generated,
+    using a pre-trained model. 
+    """
+    import streamlit as st
+    import numpy as np
+    import joblib
+    import string
+    import time
+    import scipy
+    import spacy
+    import re
+    from transformers import AutoTokenizer
+    import torch
+    from eli5.lime import TextExplainer
+    from eli5.lime.samplers import MaskingTextSampler
+    import eli5
+    import shap
+    from custom_models import HF_DistilBertBasedModelAppDocs, HF_BertBasedModelAppDocs
+
+    # Initialize Spacy
+    nlp = spacy.load("en_core_web_sm")
+    
+    # device to run DL model
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    def format_text(text: str) -> str:
+        """
+        This function takes a string as input and returns a formatted version of the string. 
+        The function replaces specific substrings in the input string with empty strings, 
+        converts the string to lowercase, removes any leading or trailing whitespace, 
+        and removes any punctuation from the string. 
+        """
+
+        text = nlp(text)
+        text = " ".join([token.text for token in text if token.ent_type_ not in ["PERSON", "DATE"]])
+
+        pattern = r"\b[A-Za-z]+\d+\b"
+        text = re.sub(pattern, "", text)
+        
+        return text.replace("REDACTED", "").lower().replace("[Name]", "").replace("[your name]", "").\
+                                replace("dear admissions committee,", "").replace("sincerely,","").\
+                                replace("[university's name]","fordham").replace("dear sir/madam,","").\
+                                replace("– statement of intent  ","").\
+                                replace('program: master of science in data analytics  name of applicant:    ',"").\
+                                replace("data analytics", "data science").replace("| \u200b","").\
+                                replace("m.s. in data science at lincoln center  ","").\
+                                translate(str.maketrans('', '', string.punctuation)).strip().lstrip()
+
+    # Define the function to classify text
+    def nb_lr(model, text):
+        # Clean and format the input text
+        text = format_text(text)
+        # Predict using either LR or NB and get prediction probability
+        prediction = model.predict([text]).item()
+        predict_proba = round(model.predict_proba([text]).squeeze()[prediction].item(),4)
+        return prediction, predict_proba
+    
+    def torch_pred(tokenizer, model, text):
+        # DL models (BERT/DistilBERT based models)
+        cleaned_text_tokens = tokenizer([text], padding='max_length', max_length=512, truncation=True)
+        with torch.inference_mode():
+            input_ids, att = cleaned_text_tokens["input_ids"], cleaned_text_tokens["attention_mask"]
+            input_ids = torch.tensor(input_ids).to(device)
+            attention_mask = torch.tensor(att).to(device)
+            logits = model(input_ids=input_ids, attention_mask=attention_mask)
+            _, prediction = torch.max(logits, 1)
+            prediction = prediction.item()
+            predict_proba = round(torch.softmax(logits, 1).numpy().squeeze()[prediction].item(),4)
+            return prediction, predict_proba
+
+    def pred_str(prediction):
+    # Map the predicted class to string output
+        if prediction == 0:
+            return "Human-made 🤷‍♂️🤷‍♀️"
+        else:
+            return "Generated with AI 🦾"
+    
+    @st.cache(allow_output_mutation=True, suppress_st_warning=True)
+    def load_tokenizer(option):
+        if option == "BERT-based model":
+            tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased", padding='max_length', max_length=512, truncation=True)
+        else:
+            tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased", padding='max_length', max_length=512, truncation=True)
+        return tokenizer
+
+    @st.cache(allow_output_mutation=True, suppress_st_warning=True)
+    def load_model(option):
+        if option == "BERT-based model":
+            model = HF_BertBasedModelAppDocs.from_pretrained("ferdmartin/HF_BertBasedModelAppDocs").to(device)
+        else:
+            model = HF_DistilBertBasedModelAppDocs.from_pretrained("ferdmartin/HF_DistilBertBasedModelAppDocs").to(device)
+        return model
+    
+
+    # Streamlit app:
+
+    models_available = {"Logistic Regression":"models/baseline_model_lr2.joblib", 
+                        "Naive Bayes": "models/baseline_model_nb2.joblib",
+                        "DistilBERT-based model (BERT light)": "ferdmartin/HF_DistilBertBasedModelAppDocs",
+                        "BERT-based model": "ferdmartin/HF_BertBasedModelAppDocs"
+                        }
+
+    st.set_page_config(layout="wide")
+    st.title("Academic Application Document Classifier")
+    st.header("Is it human-made 📝 or Generated with AI 🤖 ?  ")
+    
+    # Check the model to use
+    option = st.selectbox("Select a model to use:", models_available)
+
+    # Load the selected trained model
+    if option in ("BERT-based model", "DistilBERT-based model (BERT light)"):
+        tokenizer = load_tokenizer(option)
+        model = load_model(option)
+    else:
+        model = joblib.load(models_available[option])
+
+
+    text = st.text_area("Enter either a statement of intent or a letter of recommendation:")
+
+    #Hide footer "made with streamlit"
+    hide_st_style = """
+            <style>
+            footer {visibility: hidden;}
+            header {visibility: hidden;}
+            </style>
+            """
+    st.markdown(hide_st_style, unsafe_allow_html=True)
+
+    # Use model
+    if st.button("Let's check this text!"):
+        if text.strip() == "":
+            st.error("Please enter some text")
+        else:
+            # # Add a progress bar
+            # progress_bar = st.progress(0)
+
+            # # Add a placeholder for the progress message
+            # status_text = st.empty()
+
+            # # Simulate a long-running process
+            # for i in range(100):
+            #     # Update the progress bar every 0.02 seconds
+            #     time.sleep(0.05)
+            #     progress_bar.progress(i + 1)
+                
+            #     if i % 2 == 0:
+            #         magic = "✨"
+            #     else:
+            #         magic = ""
+            #     # Update the progress message
+            #     status_text.write(f"Work in progress {i + 1}%... Wait for the magic 🪄🔮{magic}")
+            # # Clear the progress bar and status message
+            # progress_bar.empty()
+            # status_text.empty()
+            with st.spinner("Wait for the magic 🪄🔮"):
+                # Use model
+                if option in ("Naive Bayes", "Logistic Regression"):
+                    prediction, predict_proba = nb_lr(model, text)
+                    st.session_state["sklearn"] = True
+                else:
+                    prediction, predict_proba = torch_pred(tokenizer, model, text)
+                    st.session_state["torch"] = True
+
+            # Store the result in session state
+            st.session_state["color_pred"] = "blue" if prediction == 0 else "red"
+            prediction = pred_str(prediction)
+            st.session_state["prediction"] = prediction
+            st.session_state["predict_proba"] = predict_proba
+            st.session_state["text"] = text
+            
+            # Print result
+            # st.write(f"<span style='font-size: 24px;'>I think this text is: {prediction}</span>", 
+            #         unsafe_allow_html=True)
+            st.markdown(f"I think this text is: **:{st.session_state['color_pred']}[{st.session_state['prediction']}]** (Prediction probability: {st.session_state['predict_proba'] * 100}%)")
+                   # help=f"I estimate that its probability is {st.session_state['predict_proba'] * 100}%")
+
+    elif "prediction" in st.session_state:
+        # Display the stored result if available
+        # st.write(f"<span style='font-size: 24px;'>I think this text is: {st.session_state['prediction']}</span>", unsafe_allow_html=True)
+        
+        st.markdown(f"I think this text is: **:{st.session_state['color_pred']}[{st.session_state['prediction']}]** (Prediction probability: {st.session_state['predict_proba'] * 100}%)")
+                   #help=f"I estimate that its probability is {st.session_state['predict_proba'] * 100}%")
+        #**:blue[colored]**
+    if st.button("Model Explanation"):
+        # Check if there's text in the session state
+        if "text" in st.session_state:
+           
+            if option in ("Naive Bayes", "Logistic Regression"):
+                 with st.spinner('Wait for it 💭...'):
+                    explainer = TextExplainer(sampler=MaskingTextSampler())
+                    explainer.fit(st.session_state["text"], model.predict_proba)
+                    html = eli5.format_as_html(explainer.explain_prediction(target_names=["Human", "AI"]))
+            else:
+                with st.spinner('Wait for it 💭... BERT-based model explanations take around 4-10 minutes. In case you want to abort, refresh the page.'):
+                # TORCH EXPLAINER PRED FUNC (USES logits)
+                    def f(x):
+                        tv = torch.tensor([tokenizer.encode(v, padding='max_length', max_length=512, truncation=True) for v in x])#.cuda()
+                        outputs = model(tv).detach().cpu().numpy()
+                        scores = (np.exp(outputs).T / np.exp(outputs).sum(-1)).T
+                        val = scipy.special.logit(scores[:,1]) # use one vs rest logit units
+                        return val
+                    # build an explainer using a token masker
+                    explainer = shap.Explainer(f, tokenizer)
+                    shap_values = explainer([st.session_state["text"]], fixed_context=1)
+                    html = shap.plots.text(shap_values, display=False)
+            # Render HTML
+            st.components.v1.html(html, height=500, scrolling = True)
+        else:
+            st.error("Please enter some text and click 'Let's check!' before requesting an explanation.") 
+            
+if __name__ == "__main__":
+    main()

custom_models.py

@@ -0,0 +1,87 @@
+from typing import Optional
+from transformers import PreTrainedModel, PretrainedConfig, DistilBertModel, BertModel
+import torch
+from torch import nn
+
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+class TransformerBasedModelDistilBert(nn.Module):
+    def __init__(self):
+        super(TransformerBasedModelDistilBert, self).__init__()
+        self.bert = DistilBertModel.from_pretrained('distilbert-base-uncased')
+        self.dropout = nn.Dropout(0.55)
+        self.fc = nn.Linear(768, 2)
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None):
+        input_shape = input_ids.size()
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+            
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.last_hidden_state[:, 0, :]
+        pooled_output = self.dropout(pooled_output)
+        logits = self.fc(pooled_output)
+        return logits
+
+class TransformerBasedModelBert(nn.Module):
+    def __init__(self):
+        super(TransformerBasedModelBert, self).__init__()
+        self.bert = BertModel.from_pretrained('bert-base-uncased')
+        self.dropout = nn.Dropout(0.55)
+        self.fc = nn.Linear(768, 2)
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None):
+        input_shape = input_ids.size()
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+            
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs[1]
+        pooled_output = self.dropout(pooled_output)
+        logits = self.fc(pooled_output)
+        return logits
+
+class MyConfigDistil(PretrainedConfig):
+    model_type = "distilbert"
+    def __init__(self, final_dropout=0.55, **kwargs):
+        super().__init__(**kwargs)
+        self.final_dropout = final_dropout
+
+class MyConfig(PretrainedConfig):
+    model_type = "bert"
+    def __init__(self, final_dropout=0.55, **kwargs):
+        super().__init__(**kwargs)
+        self.final_dropout = final_dropout
+        
+class MyHFModel_DistilBertBased(PreTrainedModel):
+    config_class = MyConfigDistil
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.model = TransformerBasedModelDistilBert()
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None):
+        input_shape = input_ids.size()
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+
+        return self.model(input_ids=input_ids, attention_mask=attention_mask)
+
+class MyHFModel_BertBased(PreTrainedModel):
+    config_class = MyConfig
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        self.model = TransformerBasedModelBert()
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None):
+        input_shape = input_ids.size()
+        if attention_mask is None:
+            attention_mask = torch.ones(input_shape, device=device)
+
+        return self.model(input_ids=input_ids, attention_mask=attention_mask) 
+
+config = MyConfigDistil(0.55)
+HF_DistilBertBasedModelAppDocs = MyHFModel_DistilBertBased(config)
+
+config_db = MyConfig(0.55)
+HF_BertBasedModelAppDocs = MyHFModel_BertBased(config_db)

models/baseline_model_lr2.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd46197ecc509dbc783af2ca0e2fac048e76a21047a9b6f52f8cc761dcfdc665
+size 2206719

models/baseline_model_nb2.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4d8e375acf6e9bf81062baf862cdcf84fd78c236dea4c649f9e8e648b0c8712
+size 3371095

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+psutil
+scikit-learn==1.0.2
+scipy==1.7.3
+shap
+numpy==1.21.6
+matplotlib==3.5.3
+eli5==0.13.0
+torch
+transformers
+spacy
+https://huggingface.co/spacy/en_core_web_sm/resolve/main/en_core_web_sm-any-py3-none-any.whl