Upload 5 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Gabriel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,30 @@
----
-title: My Own Chatbot
-emoji: 📉
-colorFrom: purple
-colorTo: blue
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# My Own Chatbot
+- My Own Chatbot with an interface implemented without APIs using a pre-trained model.
+
+# Why
+- Just to see if it was possible. (and to see if I could)
+
+# Model Information
+- The template I'm using is [distilbert-base-uncased-distilled-squad](https://huggingface.co/distilbert-base-uncased-distilled-squad) by [huggingface](https://huggingface.co/) team.<br>
+- This model has: `66.4M parameters.`
+- The reason i chose this model is because i like huggingface models and because this model is a base model and very light. it can be trained and has good documentation and performance.
+- The license of this model is: `Apache 2.0`
+- The Language(s): English
+- The Model Type: Transformer-based language model.
+- The Token Limit: `512 tokens` for this model.
+# Credits
+- huggingface: by model and transformers library
+- gradio: by the gradio library making it easy to create UI for machine learning models easily.
+- pytorch: very fast and lightweight tensor framework.
+- loguru: quick and easy log library.
+- [how-to-generate#greedy-search](https://huggingface.co/blog/how-to-generate#greedy-search) a very detailed guide on huggingface's website: How to generate text: using different decoding methods for language generation with Transformers
+- [gpt2#openai-gpt2](https://huggingface.co/docs/transformers/model_doc/gpt2#openai-gpt2) gpt2 documentation made by huggingface team
+
+# Not Implemented
+- Context manager: as the token limit is low (`512 tokens`), for this project to become usable for small things, it would be necessary to implement a system to avoid overflowing too many tokens into the model.
+
+# Demonstration
+[screen-capture.webm](https://github.com/0x41337/my-own-chatbot/assets/88632118/48b97fa1-fbae-493d-8311-f6c381e13c23)
+
+# License
+- this project is under the MIT license resources used may be under other licenses.

main.py

@@ -0,0 +1,71 @@
+# gradio is a UI library for machine learning models
+import gradio as gr
+
+# loguru is a library for logging
+from loguru import logger
+
+# generative pre-trained transformer model
+from model.model import Model
+
+# load model
+model = Model()
+
+# These functions are responsible for defining the chatbot's behavior
+#  when the user interacts with the interface. The respond function
+#  receives a question and a conversation history. It defines the
+#  question in the model (model.question) and calls the
+#  question_answerer method to get the answer. The response
+#  is added to the history and returned as a result.
+def respond(question, history):
+    model.question  = question
+    history.append((question, model.question_answerer()))
+    return "", history
+
+# The set_context function takes a context and sets that context in
+#  the model (model.context).
+def set_context(context):
+    model.context   = context
+
+
+# In this part, the Gradio interface is created. 
+#  the interface has two tabs: "Chat" and "Context".
+with gr.Blocks() as interface:
+    # In the "Chat" tab, there is a Chatbot component which is
+    #  used to display the chatbot conversation. There is also
+    #  a Textbox component called prompt_gradio_component
+    #  used to receive the question from the user. The
+    #  generate_gradio_component button is responsible
+    #  for calling the respond function when clicked.
+    #  The clear_gradio_component button is used to
+    #  clear input fields and conversation.
+    with gr.Tab("Chat"):
+        chatbot_gradio_component  = gr.Chatbot(label="My Own Chatbot")
+
+        prompt_gradio_component   = gr.Textbox(label="Prompt", lines=2)
+        generate_gradio_component = gr.Button("Generate")
+        clear_gradio_component    = gr.ClearButton([prompt_gradio_component, chatbot_gradio_component])
+
+        generate_gradio_component.click(respond, [prompt_gradio_component, chatbot_gradio_component], [prompt_gradio_component, chatbot_gradio_component])
+    
+    # In the "Context" tab, there is a Textbox component called
+    #  context_gradio_component used to receive the chatbot
+    #  context. The set_context_gradio_component button is
+    #  responsible for calling the set_context function
+    #  when clicked. The clear_gradio_component button
+    #  is used to clear the input field.
+    with gr.Tab("Context"):
+        context_gradio_component         = gr.Textbox(label="Context", lines=10)
+        set_context_gradio_component     = gr.Button("Set")
+        clear_gradio_component           = gr.ClearButton([context_gradio_component])
+        
+        set_context_gradio_component.click(set_context, [context_gradio_component])
+
+# In this part, the interface is launched and executed. The launch()
+#  function is called to launch the Gradio interface.
+#  If any errors occur during runtime, they are
+#  caught and logged using the loguru library.
+if __name__ == "__main__":
+    try:
+        interface.launch()
+    except Exception as error:
+        logger.error(error)

model/model.py

@@ -0,0 +1,52 @@
+# PyTorch is a library for deep learning and machine learning
+import torch
+
+# Huggingface transformer library is State-of-the-art Machine Learning for PyTorch, TensorFlow, and JAX.
+from transformers import DistilBertTokenizer, DistilBertForQuestionAnswering
+
+# the model
+class Model:
+    # The DistilBERT model and tokenizer are loaded with the pre-trained weights
+    #  of the "distilbert-base-uncased-distilled-squad" model. The variables
+    #  answer, context and question are initialized empty.
+    def __init__(self):
+        self.model       = DistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased-distilled-squad")
+        self.tokenizer   = DistilBertTokenizer.from_pretrained("distilbert-base-uncased-distilled-squad")
+        
+        self.answer      = ""
+        self.context     = ""
+        self.question    = ""
+
+    # This method receives a question (self.question) and a context (self.context).
+    #  It tokenizes the question and context using DistilBERT's tokenizer and
+    #  returns the inputs to the model, which are wrapped in the self.inputs
+    #  object.
+
+    # Then, the method performs an inference with the DistilBERT model, passing
+    #  the inputs to the self.model(**self.inputs) method. The call to
+    #  torch.no_grad() indicates that it is not necessary to compute
+    #  gradients during this inference, which saves memory resources.
+
+    # After the inference, the start and end indices of the response
+    #  within the context are obtained, using torch.argmax to find
+    #  the indices with the highest probability. These indexes are
+    #  used to extract the corresponding tokens from the predicted
+    #  response.
+
+    # Finally, the response tokens are decoded using the tokenizer,
+    #  resulting in the final response. The answer is stored in
+    #  the self.answer variable and returned by the method.
+    def question_answerer(self):
+        self.inputs = self.tokenizer(self.question, self.context, return_tensors="pt")
+        
+        # disable gradient calculations
+        with torch.no_grad():
+            self.outputs = self.model(**self.inputs)
+
+        self.answer_start_index  = torch.argmax(self.outputs.start_logits)
+        self.answer_end_index    = torch.argmax(self.outputs.end_logits)
+        
+        self.predict_answer_tokens = self.inputs.input_ids[0, self.answer_start_index : self.answer_end_index + 1]
+        self.answer = self.tokenizer.decode(self.predict_answer_tokens)
+        return self.answer
+

requirements.txt

@@ -0,0 +1,5 @@
+torch>=1.10.1
+loguru>=0.7.0
+gradio>=3.35.2
+torchvision>=0.11.2
+gradio-client>=0.2.7