Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* 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
+resources/small.guesstrain.json filter=lfs diff=lfs merge=lfs -text
+resources/wiki_page_text.json filter=lfs diff=lfs merge=lfs -text
+resources/wiki_text_16.json filter=lfs diff=lfs merge=lfs -text
+resources/wiki_text_2.json filter=lfs diff=lfs merge=lfs -text

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)
+        
+

QBModelWrapper.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()
+        self.tfmodel = self.model.guesser
+
+    
+
+    def forward(self, question):
+        return self.model.guess_and_buzz(question)

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()
+        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,60 @@
+from transformers import Pipeline
+from transformers.utils import ModelOutput
+
+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": answer}
+
+    def _process_output(self, outputs: Any) -> str:
+
+        print("in process outputs")
+
+        format =  {'guess': outputs[0], 'confidence': int(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,330 @@
+The evaluation of this project is to answer trivia questions.  You do
+not need to do well at this task, but you should submit a system that
+completes the task or create adversarial questions in that setting.  This will help the whole class share data and
+resources.
+
+If you focus on something other than predicting answers, *that's fine*!  
+
+About the Data
+==============
+
+Quiz bowl is an academic competition between schools in
+English-speaking countries; hundreds of teams compete in dozens of
+tournaments each year. Quiz bowl is different from Jeopardy, a recent
+application area.  While Jeopardy also uses signaling devices, these
+are only usable after a question is completed (interrupting Jeopardy's
+questions would make for bad television).  Thus, Jeopardy is rapacious
+classification followed by a race---among those who know the
+answer---to punch a button first.
+
+Here's an example of a quiz bowl question:
+
+Expanding on a 1908 paper by Smoluchowski, he derived a formula for
+the intensity of scattered light in media fluctuating densities that
+reduces to Rayleigh's law for ideal gases in The Theory of the
+Opalescence of Homogenous Fluids and Liquid Mixtures near the Critical
+State.  That research supported his theories of matter first developed
+when he calculated the diffusion constant in terms of fundamental
+parameters of the particles of a gas undergoing Brownian Motion.  In
+that same year, 1905, he also published On a Heuristic Point of View
+Concerning the Production and Transformation of Light.  That
+explication of the photoelectric effect won him 1921 Nobel in Physics.
+For ten points, name this German physicist best known for his theory
+of Relativity.
+
+*ANSWER*: Albert _Einstein_
+
+Two teams listen to the same question. Teams interrupt the question at
+any point by "buzzing in"; if the answer is correct, the team gets
+points and the next question is read.  Otherwise, the team loses
+points and the other team can answer.
+
+You are welcome to use any *automatic* method to choose an answer.  It
+need not be similar nor build on our provided systems.  In addition to
+the data we provide, you are welcome to use any external data *except*
+our test quiz bowl questions (i.e., don't hack our server!).  You are
+welcome (an encouraged) to use any publicly available software, but
+you may want to check on Piazza for suggestions as many tools are
+better (or easier to use) than others.
+
+If you don't like the interruptability of questions, you can also just answer entire questions.  However, you must also output a confidence.
+
+Competition
+==================
+We will use Dynabech website (https://dynabench.org/tasks/qa). If you remember the past workshop about Dynabench submission, this is the way to do it. The specific task name is "Grounded QA". Here, with the help of the video tutorial, you submit your QA model and assess how your QA model did compared to others. The assessment will take place by testing your QA model on several QA test datasets and the results of yours and your competitors will be visible on the leaderboard. Your goal is to rank the highest in terms of expected wins: you buzz in with probability proportional to your confidence, and if you're more right than the competition, you win. 
+
+Writing Questions
+==================
+
+Alternatively, you can also *write* 50 adversarial questions that
+challenge modern NLP systems. These questions must be diverse in the
+subjects asked about, the skills computers need to answer the
+questions, and the entities in those questions. Remember that your questions should be *factual* and
+*specific* enough for humans to answer, because your task is to stump
+the computers relative to humans!
+
+In addition to the raw questions, you will also need to create citations describing:
+* Why the question is difficult for computers: include citations from the NLP/AI/ML literature
+* Why the information in the question is correct: include citations from the sources you drew on the write the question
+* Why the question is interesting: include scholarly / popular culture artifacts to prove that people care about this
+* Why the question is pyramidal: discuss why your first clues are harder than your later clues
+
+**Category**
+
+We want questions from many domains such as Art, Literature, Geography, History,
+Science, TV and Film, Music, Lifestyle, and Sport. The questions
+should be written using all topics above (5 questions for each
+category and 5 more for the remaining categories). Indicate in your
+writeup which category you chose to write on for each question.
+
+
+Art:
+
+* Questions about works: Mona Lisa, Raft of the Medussa
+
+* Questions about forms: color, contour, texture
+
+* Questions about artists: Picasso, Monet, Leonardo da Vinci
+
+* Questions about context: Renaissance, post-modernism, expressionism, surrealism
+
+
+Literature: 
+
+*	Questions about works: novels (1984), plays (The Lion and the Jewel), poems (Rubaiyat), criticism (Poetics)
+
+*	Questions about major characters or events in literature: The Death of Anna Karenina, Noboru Wataya, the Marriage of Hippolyta and Theseus
+
+*	Questions about literary movements (Sturm und Drang)
+
+*	Questions about translations
+
+*	Cross-cutting questions (appearances of Overcoats in novels)
+
+*	Common link questions (the literary output of a country/region)
+
+
+Geography: 
+
+*	Questions about location: names of capital, state, river
+
+*	Questions about the place: temperature, wind flow, humidity
+
+
+History: 
+
+*	When: When did the First World war start? 
+
+*	Who: Who is called Napoleon of Iran? 
+
+*	Where: Where was the first Summer Olympics held?
+
+*	Which: Which is the oldest civilization in the world?
+
+
+Science: 
+
+*	Questions about terminology: The concept of gravity was discovered by which famous physicist?
+
+*	Questions about the experiment
+
+*	Questions about theory: The social action theory believes that individuals are influenced by this theory.
+
+
+TV and Film: 
+
+*	Quotes: What are the dying words of Charles Foster Kane in Citizen Kane?
+
+*	Title: What 1927 musical was the first "talkie"?
+
+*	Plot: In The Matrix, does Neo take the blue pill or the red pill?
+
+
+Music: 
+
+*	Singer: What singer has had a Billboard No. 1 hit in each of the last four decades?
+
+*	Band: Before Bleachers and fun., Jack Antonoff fronted what band?
+
+*	Title: What was Madonna's first top 10 hit?
+
+*	History: Which classical composer was deaf?
+
+
+Lifestyle: 
+
+*	Clothes: What clothing company, founded by a tennis player, has an alligator logo?
+
+*	Decoration: What was the first perfume sold by Coco Chanel?
+
+
+Sport: 
+
+*	Known facts: What sport is best known as the ‘king of sports’?
+
+*	Nationality: What’s the national sport of Canada?
+
+*	Sport player: The classic 1980 movie called Raging Bull is about which real-life boxer?
+
+*	Country: What country has competed the most times in the Summer Olympics yet hasn’t won any kind of medal?
+
+
+**Diversity** 
+
+Other than category diversity, if you find an ingenious way of writing questions about underrepresented countries, you will get bonus points (indicate which questions you included the diversity component in your writeup). You may decide which are underrepresented countries with your own reasonable reason (etc., less population may indicate underrepresented), but make sure to articulate this in your writeup. 
+
+* Run state of the art QA systems on the questions to show they struggle, give individual results for each question and a summary over all questions
+
+For an example of what the writeup for a single question should look like, see the adversarial HW:
+https://github.com/Pinafore/nlp-hw/blob/master/adversarial/question.tex
+
+Proposal
+==================
+
+The project proposal is a one page PDF document that describes:
+
+* Who is on your team (team sizes can be between three and six
+  students, but six is really too big to be effective; my suggestion
+  is that most groups should be between four or five).
+
+* What techniques you will explore 
+
+* Your timeline for completing the project (be realistic; you should
+  have your first submission in a week or two)
+
+Submit the proposal on Gradescope, but make sure to include all group
+members.  If all group members are not included, you will lose points.  Late days cannot be used on this
+assignment.
+
+Milestone 1
+====================== 
+
+You'll have to update how things are going: what's
+working, what isn't, and how does it change your timeline?  How does it change your division of labor?
+
+*Question Writing*: You'll need to have answers selected for all of
+your questions and first drafts of at least 15 questions.  This must
+be submitted as a JSON file so that we run computer QA systems on it.
+
+*Project*: You'll need to have made a submission to the leaderboard with something that satisfies the API.
+
+Submit a PDF updating on your progress to Gradescope.  If all team
+members are not on the submission, you will lose points.
+
+Milestone 2
+===================
+
+As before, provide an updated timeline / division of labor, provide your intermediary results.  
+
+*Question Writing*: You'll need to have reflected the feedback from the first questions and completed a first draft of at least 30 questions.  You'll also need machine results to your questions and an overall evaluation of your human/computer accuracy.
+
+*Project*: You'll need to have a made a submission to the leaderboard with a working system (e.g., not just obey the API, but actually get reasonable answers).
+
+Submit a PDF updating on your progress.
+
+Final Presentation
+======================
+
+The final presentation will be virtual (uploading a video).  In
+the final presentation you will:
+
+* Explain what you did
+
+* Who did what.  For example, for the question writing project a team of five people might write: A wrote the first draft of questions.  B and C verified they were initially answerable by a human.  B ran computer systems to verify they were challenging to a computer.  C edited the questions and increased the computer difficulty.  D and E verified that the edited questions were still answerable by a human.  D and E checked all of the questions for factual accuracy and created citations and the writeup.
+
+* What challenges you had
+
+* Review how well you did (based on the competition or your own metrics).  If you do not use the course infrastructure to evaluate your project's work, you should talk about what alternative evaluations you used, why they're appropriate/fair, and how well you did on them.
+
+* Provide an error analysis.  An error analysis must contain examples from the
+  development set that you get wrong.  You should show those sentences
+  and explain why (in terms of features or the model) they have the
+  wrong answer.  You should have been doing this all along as you
+  derive new features, but this is your final inspection of
+  your errors. The feature or model problems you discover should not
+  be trivial features you could add easily.  Instead, these should be
+  features or models that are difficult to correct.  An error analysis
+  is not the same thing as simply presenting the error matrix, as it
+  does not inspect any individual examples.  If you're writing questions, talk about examples of questions that didn't work out as intended.
+
+* The linguistic motivation for your features / how your wrote the questions.  This is a
+  computational linguistics class, so you should give precedence to
+  features / techniques that we use in this class (e.g., syntax,
+  morphology, part of speech, word sense, etc.).  Given two features
+  that work equally well and one that is linguistically motivated,
+  we'll prefer the linguistically motivated one.
+
+* Presumably you did many different things; how did they each
+  individually contribute to your final result?
+
+Each group has 10 minutes to deliver their presentation. Please record the video, and upload it to Google Drive, and include the link in your writeup submission.
+
+Final Question Submission
+======================
+
+Because we need to get the questions ready for the systems, upload your raw questions on May 10.  This doesn't include the citations or other parts of the writeup.
+
+System Submission
+======================
+
+You must submit a version of your system by May 12. It may not be perfect, but this what the question writing teams will use to test their results.
+
+Your system should be sent directly to the professor and TAs in zip files, including the correct dependencies and a working inference code. Your inference code should run successfully in the root folder (extracted from zip folder) directory with the command:
+
+```
+> python3 inference.py --data=evaluation_set.json 
+
+```
+
+The input will be in the form of a .json file () in the same format as the file the adversarial question writing team submits. The output format should also be in string.
+
+If you have any notes or comments that we should be aware of while running your code, please include them in the folder as a .txt file. Also, dependency information should be included as a .txt file. 
+
+Please prepend your email title with [2024-CMSC 470 System Submission].
+
+Project Writeup and JSON file
+======================
+
+By May 17, submit your project writeup explaining what
+you did and what results you achieved.  This document should
+make it clear:
+
+* Why this is a good idea
+* What you did
+* Who did what
+* Whether your technique worked or not
+
+For systems, please do not go over 2500 words unless you have a really good reason.
+Images are a much better use of space than words, usually (there's no
+limit on including images, but use judgement and be selective).
+
+For question writing, you have one page (single spaced, two column) per question plus a two page summary of results. Talk about how you organized the question writing, how you evaluated the questions, and a summary of the results.  Along with your writeup, turn in a json including the raw text of the question and answer and category. The json file is included in this directory. Make sure your json file is in the correct format and is callable via below code. Your submission will not be graded if it does not follow the format of the example json file.
+
+```
+with open('path to your json file', 'r') as f:
+    data = json.load(f)
+```
+
+
+
+Grade
+======================
+
+The grade will be out of 25 points, broken into five areas:
+
+* _Presentation_: For your oral presentation, do you highlight what
+  you did and make people care?  Did you use time well during the
+  presentation?
+
+* _Writeup_: Does the writeup explain what you did in a way that is
+  clear and effective?
+
+The final three areas are different between the system and the questions.
+
+|    |      System      |  Questions |
+|----------|:-------------:|------:|
+| _Technical Soundness_ |  Did you use the right tools for the job, and did you use them correctly?  Were they relevant to this class? | Were your questions correct and accurately cited. |
+| _Effort_ |  Did you do what you say you would, and was it the right ammount of effort.  | Are the questions well-written, interesting, and thoroughly edited? |
+| _Performance_ | How did your techniques perform in terms of accuracy, recall, etc.? | Is the human accuracy substantially higher than the computer accuracy? |
+
+All members of the group will receive the same grade.  It's impossible for the course staff to adjudicate Rashomon-style accounts of who did what, and the goal of a group project is for all team members to work together to create a cohesive project that works well together.  While it makes sense to divide the work into distinct areas of responsibility, at grading time we have now way to know who really did what, so it's the groups responsibility to create a piece of output that reflects well on the whole group.

huggingface.py

@@ -0,0 +1,46 @@
+from QBModelConfig import QBModelConfig
+from QBModelWrapper import QBModelWrapper
+from transformers import AutoConfig, AutoModel, AutoModelForQuestionAnswering
+import torch 
+import numpy as np
+from transformers import QuestionAnsweringPipeline
+from transformers import PretrainedConfig
+from transformers.pipelines import PIPELINE_REGISTRY
+from transformers import AutoModelForQuestionAnswering, TFAutoModelForQuestionAnswering
+from transformers import pipeline
+
+
+
+# class DemoQAPipeline(QuestionAnsweringPipeline):
+#     def postprocess(self, model_outputs):
+#         answers = super().postprocess(model_outputs)
+#         return {'guess': answers['answer'], 'confidence': answers['score']}
+
+
+AutoConfig.register("QA-umd-quizbowl", QBModelConfig)
+AutoModel.register(QBModelConfig, QBModelWrapper)
+AutoModelForQuestionAnswering.register(QBModelConfig, QBModelWrapper)
+
+QBModelConfig.register_for_auto_class()
+QBModelWrapper.register_for_auto_class("AutoModel")
+QBModelWrapper.register_for_auto_class("AutoModelForQuestionAnswering")
+
+# PIPELINE_REGISTRY.register_pipeline(
+#     "demo-qa",
+#     pipeline_class=DemoQAPipeline,
+#     pt_model=AutoModelForQuestionAnswering,
+#     tf_model=TFAutoModelForQuestionAnswering,
+# )
+
+
+
+qbmodel_config = QBModelConfig()
+qbmodel = QBModelWrapper(qbmodel_config)
+
+# # qbmodel_config.save_pretrained("hf-model-config")
+#qbmodel.save_pretrained(save_directory='hf-model-save', safe_serialization= False, push_to_hub=True)
+qbmodel.push_to_hub("quiz-bowl-model-qa-new-attempt-v2")
+
+# model = AutoModelForQuestionAnswering.from_pretrained("nes470/hf-model-save", trust_remote_code = True)
+# qa_pipe = pipeline("question-answering", model=model)
+

models/processed_tfidf_wiki_16_model.pkl

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

models/processed_tfidf_wiki_page_text_model.pkl

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

qbmodel.py

@@ -0,0 +1,52 @@
+from typing import List, Tuple
+import nltk
+import sklearn
+from tfidf import TfidfWikiGuesser
+import numpy as np
+import pandas as pd
+
+
+class QuizBowlModel:
+
+    def __init__(self):
+        """
+        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) #can specify different wikidump if needed 
+        print("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(guesses)
+
+            #do the buzzing 
+
+            #make a tuple and add to answers list 
+            tup = (guesses[0], True)
+            answers.append(tup)
+
+        return answers
+
+
+        

questions.json

@@ -0,0 +1 @@
+[{"text": "The reciprocal of what quantity was estimated to be .9 higher than the three-digit integer value popularly associated with it in 1916 experiments conducted by a Brandenburg-based researcher? That researcher also hosted Ho Zah-wei ( 何泽慧 ) in his home; she would later go on to lead the neutron flux team of the Chinese nuclear program.", "answer": "Fine-structure_constant", "category": "Science"}]

resources/sample_questions

@@ -0,0 +1,2 @@
+q: "An object orbiting this planet contains sections named Liberty, Equality, and Fraternity. A small group of clouds on this planet was nicknamed \"the Scooter\" for its high speed. Volcanoes that eject ice were first observed on an object that orbits this planet. The first high resolution images of this object were taken by Voyager 2 and revealed a storm system known as the \"Great Dark Spot\". Johann Galle first observed this planet from a telescope using predictions made by Urbain Le Verrier [\"ur-BAIN le vay-ree-AY\"] about its effects on the orbit of Uranus. For 10 points, name this dark blue gas giant, the outermost planet in the Solar System."
+a: Neptune 

resources/small.guesstrain.json

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

resources/wiki_page_text.json

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

resources/wiki_text_16.json

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

resources/wiki_text_2.json

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

resources/wiki_text_4.json.zip

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

resources/wiki_text_8.json.zip

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

test-huggingface

@@ -0,0 +1,44 @@
+from QBModelWrapperCopy import QBModelWrapper
+from QBModelConfig import QBModelConfig
+from QBpipeline import QApipeline
+from transformers.pipelines import PIPELINE_REGISTRY
+from transformers import AutoModelForQuestionAnswering, TFAutoModelForQuestionAnswering
+from transformers import pipeline
+from transformers import AutoConfig, AutoModel, AutoModelForQuestionAnswering, TFAutoModel
+    
+config = QBModelConfig()
+qb_model = QBModelWrapper(config)
+
+# qa_pipe = QApipeline(model=qb_model)
+
+
+AutoConfig.register("QA-umd-quizbowl", QBModelConfig)
+AutoModel.register(QBModelConfig, QBModelWrapper)
+AutoModelForQuestionAnswering.register(QBModelConfig, QBModelWrapper)
+# TFAutoModel.register(QBModelConfig, QBModelWrapper)
+# TFAutoModelForQuestionAnswering(QBModelConfig, QBModelWrapper)
+
+QBModelConfig.register_for_auto_class()
+QBModelWrapper.register_for_auto_class("AutoModel")
+QBModelWrapper.register_for_auto_class("AutoModelForQuestionAnswering")
+
+
+# result = qa_pipe(question="This star in the solar system has 8 planets", context="Context for the question")
+# print(result["answer"])
+
+PIPELINE_REGISTRY.register_pipeline(
+    "qa-pipeline-qb",
+    pipeline_class=QApipeline,
+    pt_model=AutoModelForQuestionAnswering,
+    tf_model=TFAutoModelForQuestionAnswering, 
+    # pt_model=AutoModel,
+    # tf_model=TFAutoModel
+)
+
+qa_pipe = pipeline("qa-pipeline-qb", model=qb_model)
+#qa_pipe.push_to_hub("new-attempt-pipeline-2", safe_serialization=False)
+
+result = qa_pipe(question="This star in the solar system has 8 planets", context="Context for the question")
+print(result["answer"])
+
+#if still doesnt work then try making custom pipeline that inherits from QuestionAnsweringPipeline

testqb.py

@@ -0,0 +1,125 @@
+from qbmodel import QuizBowlModel
+import json 
+import pandas as pd 
+
+
+
+def compare_answers(str1: str, str2: str):
+    stripped_1 = ''.join(c.lower() for c in str1 if not c.isspace())
+    stripped_2 = ''.join(c.lower() for c in str2 if not c.isspace())
+
+
+    if stripped_1 == stripped_2:
+          return True 
+    
+    if stripped_1.find(stripped_2) != -1:
+          return True 
+    
+    if stripped_2.find(stripped_1) != -1:
+          return True 
+    
+    stripped_1 = stripped_1.replace("_", "")
+    stripped_1 = stripped_1.replace("-", "")
+    stripped_2 = stripped_2.replace("_", "")
+    stripped_2 = stripped_2.replace("-", "")
+
+    strip = [',','[',']','{','}', '.', '!', '(', ')', ';', ':', '\'',"\""]
+    stripped_1  = stripped_1.translate({ord(c): '' for c in strip})
+    stripped_2 = stripped_2.translate({ord(c): '' for c in strip})
+
+    if stripped_1 == stripped_2:
+          return True 
+    
+    if stripped_1.find(stripped_2) != -1:
+          return True 
+    
+    if stripped_2.find(stripped_1) != -1:
+          return True 
+
+    return False
+
+
+
+qb = QuizBowlModel()
+
+question = '''An object orbiting this planet contains sections named Liberty, Equality, and Fraternity.
+ A small group of clouds on this planet was nicknamed \"the Scooter\" for its high speed. 
+ Volcanoes that eject ice were first observed on an object that orbits this planet.
+ The first high resolution images of this object were taken by Voyager 2 and revealed a storm system known as the \"Great Dark Spot\".
+ Johann Galle first observed this planet from a telescope using predictions made by Urbain Le Verrier [\"ur-BAIN le vay-ree-AY\"] about its effects on the orbit of Uranus.
+ For 10 points, name this dark blue gas giant, the outermost planet in the Solar System.
+'''
+
+
+#can split question into chunks to see how guesser works on harder difficulty. 
+splits = question.split(".")
+
+data_source = 'resources/small.buzztrain.json'
+with open(data_source) as f:
+            doc = json.load(f)
+questions_json = doc['questions']
+questions = []
+answers = []
+limit = 2000 #only test this many or less questions 
+for question_json in questions_json:
+    question = question_json['text']
+    answer = question_json['answer']
+    questions.append(question)
+    answers.append(answer)
+
+    limit -= 1 
+    if limit < 0:
+          break 
+
+
+
+
+#questions = # splits #[question]
+result = qb.guess_and_buzz(questions)
+correct = 0 
+almost_correct = 0
+
+guesses = []
+buzz = []
+correct_answer = []
+for idx, (result_answer, result_bool) in enumerate(result): 
+        if answers[idx] == result_answer:
+            correct += 1 
+            guesses.append(result_answer)
+            correct_answer.append(result_answer)
+            buzz.append(True)
+            #print("correct | question: " + questions[idx] + " | answer: " + result_answer)
+        elif answers[idx].find(result_answer) != -1:
+            print("almost | correct answer: " + answers[idx] + " | result: " + result_answer)
+            almost_correct += 1
+            guesses.append(result_answer)
+            correct_answer.append(answers[idx])
+            buzz.append(True)
+        elif compare_answers(result_answer, answers[idx]):
+            almost_correct += 1
+            guesses.append(result_answer)
+            correct_answer.append(answers[idx])
+            buzz.append(True)
+        else:
+            guesses.append(result_answer)
+            correct_answer.append(answers[idx])
+            buzz.append(False)
+
+data_df = pd.DataFrame({
+      'question': questions,
+      'correct_answer': correct_answer,
+      'guess': guesses,
+      'buzz': buzz
+})
+
+#json.dump(data_df)
+data_df.to_csv('output_data_csv')
+
+
+
+correct_acc = correct/(len(answers))    
+almost_acc = (correct+almost_correct)/(len(answers))       
+print("correct: " + str(correct_acc))
+print("almost_correct: " + str(almost_acc))
+
+

tfidf-vectorizer.pkl

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

tfidf.ipynb

@@ -0,0 +1,101 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.metrics.pairwise import cosine_similarity\n",
+    "import zipfile\n",
+    "import json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_corpus(json_file):\n",
+    "    corpus = []\n",
+    "    page_titles = []\n",
+    "    \n",
+    "    for json_obj in json_file:\n",
+    "        corpus.append(json_obj['text'])\n",
+    "        page_titles.append(json_obj['page'])\n",
+    "\n",
+    "\n",
+    "    return (corpus, page_titles)\n",
+    "\n",
+    "with zipfile.ZipFile('resources/wiki_text_4.json.zip', 'r') as z:\n",
+    "    with z.open('wiki_text_4.json') as f:\n",
+    "        doc = json.load(f)\n",
+    "#wiki dump is an json array of json objects with page and text fields \n",
+    "# with open('resources/wiki_text_16.json') as f:\n",
+    "#     doc = json.load(f)\n",
+    "\n",
+    "corpus, titles = create_corpus(doc)\n",
+    "\n",
+    "vectorizer = TfidfVectorizer()\n",
+    "tfidf = vectorizer.fit_transform(corpus)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"An object orbiting this planet contains sections named Liberty, Equality, and Fraternity. A small group of clouds on this planet was nicknamed \\\"the Scooter\\\" for its high speed. Volcanoes that eject ice were first observed on an object that orbits this planet. The first high resolution images of this object were taken by Voyager 2 and revealed a storm system known as the \\\"Great Dark Spot\\\". Johann Galle first observed this planet from a telescope using predictions made by Urbain Le Verrier [\\\"ur-BAIN le vay-ree-AY\\\"] about its effects on the orbit of Uranus. For 10 points, name this dark blue gas giant, the outermost planet in the Solar System.\"\n",
+    "tfidf_question = vectorizer.transform([question])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Methods_of_detecting_exoplanets\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = cosine_similarity(tfidf, tfidf_question) \n",
+    "\n",
+    "#get index of best matching document and use it to get sim document \n",
+    "sim_index = sim.argmax()\n",
+    "sim_doc = corpus[sim_index]\n",
+    "\n",
+    "print(titles[sim_index])\n",
+    "# titles"
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

tfidf.py

@@ -0,0 +1,104 @@
+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 models import processed_tfidf_wiki_page_text_model
+
+
+class TfidfWikiGuesser:
+    def __init__(self, wikidump = 'resources/wiki_text_16.json') -> None:
+        self.tfidf = None 
+        self.corpus = None 
+        self.titles = None 
+        self.vectorizer = None 
+        self.lemmatizer = WordNetLemmatizer()
+        mod_file = processed_tfidf_wiki_page_text_model
+        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_tfidf_wiki_16_model.pkl"
+        # full_model_path = model_file
+        full_model_path = os.path.join("./models", model_file)
+
+        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']