Upload folder using huggingface_hub

LogRegBuzzer.py

@@ -0,0 +1,93 @@
+from sklearn.linear_model import LogisticRegression
+import joblib
+from huggingface_hub import hf_hub_download
+from transformers import pipeline
+import pandas as pd 
+
+
+class LogisticRegressionBuzzer:
+
+    def __init__(self) -> None:
+        self.model = self.load_from_hf_pkl()
+        self.features = BuzzerFeatures()
+
+
+    def load_from_hf_pkl(self) -> LogisticRegression:
+        REPO_ID = "nes470/pipeline-as-repo"
+        FILENAME = "logreg_buzzer_model.pkl"
+
+        model = joblib.load(
+            hf_hub_download(repo_id=REPO_ID, filename=FILENAME)
+        )
+
+        return model 
+    
+    def predict_buzz(self, question, guess):
+        X = self.features.get_features(question, guess)
+
+        X_formatted = pd.DataFrame(X, index=[0])
+        pred = self.model.predict(X_formatted)
+
+        print(pred)
+        #use predict_proba to get confidence probabilities 
+        prob_pred = self.model.predict_proba(X_formatted)
+        print(prob_pred)
+
+        return (pred, float(pred[0]))
+    
+
+    
+
+class BuzzerFeatures:
+    def __init__(self) -> None:
+        self.ner =  pipeline("ner")
+
+    #returns dict with all the features 
+    def get_features(self, question, guess):
+        sent_count = self.sentence_count(question)
+        guess_word_count = self.guess_word_count(guess)
+        guess_has_paren = self.guess_has_paren(guess)
+        guess_length = self.guess_length(guess)
+        guess_entity = self.guess_entity(guess)
+        
+        feats = {'sentence_count':sent_count, 'guess_word_count':guess_word_count,
+              'guess_has_paren':guess_has_paren, 'guess_length':guess_length}
+        
+        X = feats | guess_entity
+
+        return X 
+
+
+
+
+    def sentence_count(self, str):
+        return len(str.split("."))
+
+    def guess_word_count(self, str):
+        return len(str.split("_"))
+
+    def guess_has_paren(self, str):
+        return int("(" in str or ")" in str)
+
+    def guess_length(self, str):
+        return len(str)
+    
+    def guess_entity(self, text):
+        entities = self.ner(text)
+        if len(entities) == 0:
+            type =  ""  # <-- use "None" instead TODO
+        else:
+            type = entities[0]["entity"]
+
+        if type == "":
+            return {'':1, 'I-LOC':0, 'I-MISC':0, 'I-ORG':0, 'I-PER':0}
+        if type == "I-LOC":
+            return {'':0, 'I-LOC':1, 'I-MISC':0, 'I-ORG':0, 'I-PER':0}
+        if type == "I-MISC":
+            return {'':0, 'I-LOC':0, 'I-MISC':1, 'I-ORG':0, 'I-PER':0}
+        if type == "I-ORG":
+            return {'':0, 'I-LOC':0, 'I-MISC':0, 'I-ORG':1, 'I-PER':0}
+        if type == "I-PER":
+            return {'':0, 'I-LOC':0, 'I-MISC':0, 'I-ORG':0, 'I-PER':1}
+            
+

QBModelConfig.py

@@ -0,0 +1,11 @@
+from transformers import PretrainedConfig
+import torch
+
+class QBModelConfig(PretrainedConfig):
+    model_type = 'QA-umd-quizbowl'
+
+    def __init__(self, **kwargs):
+        self.torch_dtype = torch.float16
+        super().__init__( **kwargs)
+        
+

QBModelWrapperCopy.py

@@ -0,0 +1,20 @@
+from typing import List
+from transformers import PreTrainedModel
+from transformers import PretrainedConfig
+from .QBModelConfig import QBModelConfig
+from .qbmodel import QuizBowlModel
+
+class QBModelWrapper(PreTrainedModel):
+    config_class= QBModelConfig
+
+
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.model = QuizBowlModel(use_hf_pkl=True)
+        self.tfmodel = self.model.guesser
+
+    
+    def forward(self, question, context):
+        output = self.model.guess_and_buzz([question])
+        return output[0]

QBpipeline.py

@@ -0,0 +1,61 @@
+from transformers import Pipeline
+from transformers import PreTrainedTokenizer
+from transformers.utils import ModelOutput
+import torch 
+from transformers import PreTrainedModel, Pipeline
+from typing import Any, Dict, List
+
+class QApipeline(Pipeline):
+    def __init__(
+        self,
+        model: PreTrainedModel,
+        **kwargs
+    ):
+        super().__init__(
+            model=model,
+            **kwargs
+        )
+
+        print("in __init__")
+
+    def __call__( self, question: str,  context: str, **kwargs) -> Dict[str, Any]:
+        inputs = {
+            "question": question,
+            "context": context
+        }
+
+        outputs = self.model(**inputs)
+
+        answer = self._process_output(outputs)
+
+        print("in __call___")
+
+        return answer 
+
+    def _process_output(self, outputs: Any) -> str:
+
+        print("in process outputs")
+
+        format =  {'guess': outputs[0], 'confidence': outputs[1]}
+        return format
+
+    
+    def _sanitize_parameters(self, **kwargs):
+        print("in sanatize params")
+
+        return {}, {}, {}
+
+    def preprocess(self, inputs):
+        print("in preprocess")
+
+        return inputs
+
+    def postprocess(self, outputs):
+        print("in postprocess")
+        format =  {'guess': outputs[0], 'confidence': float(outputs[1])}
+        return format
+    
+    def _forward(self, input_tensors, **forward_parameters: Dict) -> ModelOutput:
+        print("in _forward")
+        return super()._forward(input_tensors, **forward_parameters)
+    

README.md

@@ -0,0 +1,199 @@
+---
+library_name: transformers
+license: mit
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]

config.json

@@ -0,0 +1,23 @@
+{
+  "architectures": [
+    "QBModelWrapper"
+  ],
+  "auto_map": {
+    "AutoConfig": "QBModelConfig.QBModelConfig",
+    "AutoModelForQuestionAnswering": "QBModelWrapperCopy.QBModelWrapper"
+  },
+  "custom_pipelines": {
+    "qa-pipeline-qb": {
+      "impl": "QBpipeline.QApipeline",
+      "pt": [
+        "AutoModelForQuestionAnswering"
+      ],
+      "tf": [
+        "TFAutoModelForQuestionAnswering"
+      ]
+    }
+  },
+  "model_type": "QA-umd-quizbowl",
+  "torch_dtype": "float16",
+  "transformers_version": "4.40.1"
+}

pytorch_model.bin

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

qbmodel.py

@@ -0,0 +1,61 @@
+from typing import List, Tuple
+import nltk
+import sklearn
+from .tfidf import TfidfWikiGuesser
+import numpy as np
+import pandas as pd
+from .LogRegBuzzer import LogisticRegressionBuzzer
+
+
+class QuizBowlModel:
+
+    def __init__(self, use_hf_pkl = False):
+        """
+        Load your model(s) and whatever else you need in this function.
+
+        Do NOT load your model or resources in the guess_and_buzz() function, 
+        as it will increase latency severely. 
+        """
+        #best accuracy when using wiki_page_text.json
+        self.guesser = TfidfWikiGuesser(wikidump=None, use_hf_pkl= use_hf_pkl) #can specify different wikidump if needed 
+        print("guesser model loaded")
+
+        self.buzzer = LogisticRegressionBuzzer()
+        print("buzzer model loaded")
+
+
+    def guess_and_buzz(self, question_text: List[str]) -> List[Tuple[str, bool]]:
+        """
+        This function accepts a list of question strings, and returns a list of tuples containing
+        strings representing the guess and corresponding booleans representing 
+        whether or not to buzz. 
+
+        So, guess_and_buzz(["This is a question"]) should return [("answer", False)]
+
+        If you are using a deep learning model, try to use batched prediction instead of 
+        iterating using a for loop.
+        """
+
+        answers = []
+        top_guesses = 3 #guesser will return this amount guesses for each question (in sorted confidence)
+
+        for question in question_text:
+            guesses = self.guesser.make_guess(question, num_guesses=top_guesses)
+            # print(f"\n\n\n answered {len(answers)} questions so far \n\n")
+            # print(f"left to answer {len(question_text)-len(answers)} questions \n\n ")
+            # print(f"progress: {(len(answers)/len(question_text)) * 100} \n\n")
+
+            #do the buzzing 
+            buzz = self.buzzer.predict_buzz(question, guesses[0])
+            
+
+            #make a tuple and add to answers list 
+            tup = (guesses[0], buzz[1])
+            print(tup)
+            answers.append(tup)
+            #might neeed to format guees like replace _ with space 
+
+        return answers
+
+
+        

tfidf.py

@@ -0,0 +1,124 @@
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np 
+import json
+import zipfile
+import pickle
+import os
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from nltk.stem import WordNetLemmatizer
+from huggingface_hub import hf_hub_download
+import joblib
+
+
+class TfidfWikiGuesser:
+    def __init__(self, wikidump = 'resources/wiki_text_16.json', use_hf_pkl = False) -> None:
+        self.tfidf = None 
+        self.corpus = None 
+        self.titles = None 
+        self.vectorizer = None 
+        self.lemmatizer = WordNetLemmatizer()
+        model_file = "processed_tfidf_wiki_page_text_model.pkl" # <--- has best acc so far (using wiki_page_text.json from gdrive folder)
+        #model_file = "processed_large_wiki_text_model.pkl"
+        #model_file = "processed_tfidf_wiki_16_model.pkl"
+        # full_model_path = model_file
+        full_model_path = os.path.join("./models", model_file)
+
+        if(use_hf_pkl):
+            REPO_ID = "nes470/pipeline-as-repo"
+            FILENAME = "processed_tfidf_wiki_page_text_model.pkl"
+
+            model = joblib.load(
+                hf_hub_download(repo_id=REPO_ID, filename=FILENAME)
+            )
+            
+        
+            print("loading from hugginface pkl file")
+            self.load_from_pk_direct(model)
+        else:
+            if os.path.exists(full_model_path):
+                print("Loading model from pickle...")
+                self.load_from_pkl(full_model_path)
+            else:
+                if wikidump:
+                    print("No pre-trained model found, loading data from dump...")
+                    self.load_model(wikidump)
+                    self.save_model(full_model_path)
+        # self.load_model(wikidump)
+
+    def load_model(self, wikidump):
+        # wiki dump is an json array of json objects with page and text fields 
+        with open(wikidump) as f:
+            doc = json.load(f)
+        # with zipfile.ZipFile('resources/wiki_text_8.json.zip', 'r') as z:
+        #     with z.open('wiki_text_8.json') as f:
+        #         doc = json.load(f)
+
+
+        self.corpus, self.titles = self.create_corpus(doc)
+
+        self.vectorizer = TfidfVectorizer(stop_words='english')
+        self.tfidf = self.vectorizer.fit_transform(self.corpus)
+
+    def preprocess_text(self,text):
+        if type(text) == float:
+            return str(text)
+        tokens = word_tokenize(text.lower())
+        filtered_tokens = [token for token in tokens if token not in stopwords.words('english')]
+        lemmatized_tokens = [self.lemmatizer.lemmatize(token) for token in filtered_tokens]
+        processed_text = ' '.join(lemmatized_tokens)
+        return processed_text
+
+    def create_corpus(self, json_file):
+        corpus = []
+        page_titles = []
+        
+        for json_obj in json_file:
+            # corpus.append(json_obj['text'])
+            #corpus.append(self.preprocess_text(json_obj['text']))
+            corpus.append(json_obj['text'])
+            page_titles.append(json_obj['page'])
+
+        return (corpus, page_titles)
+
+    def make_guess(self, question, num_guesses = 1):
+        tfidf_question = self.vectorizer.transform([question])
+
+        sim = cosine_similarity(self.tfidf, tfidf_question) 
+
+        #get indices of best matching documents and use it to get (num_guesses) top documents 
+        sim_indices = np.argsort(sim.flatten())[::-1]
+        best_indices = sim_indices[:num_guesses]
+        
+        # best_docs = []
+        best_guesses = []
+        for i in best_indices:
+            # best_docs.append(self.corpus[i])
+            best_guesses.append(self.titles[i])
+
+        return best_guesses
+        
+    def save_model(self, file_name):
+        with open(file_name, 'wb') as f:
+            pickle.dump({
+                'vectorizer': self.vectorizer,
+                'tfidf_matrix': self.tfidf,
+                'titles': self.titles,
+                # 'corpus': self.corpus
+            }, f)
+
+    def load_from_pkl(self, file_name):
+        with open(file_name, 'rb') as f:
+            data = pickle.load(f)
+            self.vectorizer = data['vectorizer']
+            self.tfidf = data['tfidf_matrix']
+            self.titles = data['titles']
+            # self.corpus = data['corpus']
+
+    def load_from_pk_direct(self, pkl):
+        #data = pickle.load(pkl)
+        data = pkl
+        self.vectorizer = data['vectorizer']
+        self.tfidf = data['tfidf_matrix']
+        self.titles = data['titles']