Update README.md

README.md

@@ -58,128 +58,106 @@ This model is not meant as a decision support system in the wild, only for educa
 
 ## How to Get Started with the Model
 
+Try it here : [Pseudolab/GaiaMiniMed](https://huggingface.co/spaces/pseudolab/GaiaMiniMed)
+
+See the [author's demo](https://huggingface.co/spaces/tonic/gaiaminimed)
+
 Use the code below to get started with the model.
 
 ```python
-from transformers import AutoConfig, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM, MistralForCausalLM
-from peft import PeftModel, PeftConfig
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 import gradio as gr
-import random
-from textwrap import wrap
-
-# Functions to Wrap the Prompt Correctly
-def wrap_text(text, width=90):
-    lines = text.split('\n')
-    wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
-    wrapped_text = '\n'.join(wrapped_lines)
-    return wrapped_text
-
-def multimodal_prompt(user_input, system_prompt="You are an expert medical analyst:"):
-    """
-    Generates text using a large language model, given a user input and a system prompt.
-    Args:
-        user_input: The user's input text to generate a response for.
-        system_prompt: Optional system prompt.
-    Returns:
-        A string containing the generated text.
-    """
-    # Combine user input and system prompt
-    formatted_input = f"Question: {system_prompt} {user_input} \n Mini :"
-
-    # Encode the input text
-    encodeds = tokenizer(formatted_input, return_tensors="pt", add_special_tokens=False)
-    model_inputs = encodeds.to(device)
-
-    # Generate a response using the model
-    output = model.generate(
-        **model_inputs,
-        max_length=max_length,
-        use_cache=True,
-        early_stopping=True,
-        bos_token_id=model.config.bos_token_id,
-        eos_token_id=model.config.eos_token_id,
-        pad_token_id=model.config.eos_token_id,
-        temperature=0.1,
-        do_sample=True
-    )
-
-    # Decode the response
-    response_text = tokenizer.decode(output[0], skip_special_tokens=True)
-
-    return response_text
 
 # Define the device
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Use the base model's ID
+# Use model IDs as variables
 base_model_id = "mistralai/Mistral-7B-v0.1"
 model_directory = "Tonic/GaiaMiniMed"
 
 # Instantiate the Tokenizer
-tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1", trust_remote_code=True, padding_side="left")
-# tokenizer = AutoTokenizer.from_pretrained("Tonic/mistralmed", trust_remote_code=True, padding_side="left")
+tokenizer = AutoTokenizer.from_pretrained(base_model_id, trust_remote_code=True, padding_side="left")
 tokenizer.pad_token = tokenizer.eos_token
 tokenizer.padding_side = 'left'
 
-# Load the GaiaMiniMed model with the specified configuration
-
-peft_config = PeftConfig.from_pretrained("Tonic/GaiaMiniMed")
-peft_model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-7b-instruct")
-peft_model = PeftModel.from_pretrained(model, "Tonic/GaiaMiniMed")
-
-# Specify the configuration class for the model
-#model_config = AutoConfig.from_pretrained(base_model_id)
-
-# Load the PEFT model with the specified configuration
-#peft_model = AutoModelForCausalLM.from_pretrained(base_model_id, config=model_config)
-
-# Load the PEFT model
-# peft_config = PeftConfig.from_pretrained("Tonic/mistralmed", token="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")
-# peft_model = MistralForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", trust_remote_code=True)
-# peft_model = PeftModel.from_pretrained(peft_model, "Tonic/mistralmed", token="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")
-
-class ChatBot:
-    def __init__(self):
-        self.history = []
-
-class ChatBot:
-    def __init__(self):
-        # Initialize the ChatBot class with an empty history
-        self.history = []
-
-    def predict(self, user_input, system_prompt="You are an expert medical analyst:"):
-        # Combine the user's input with the system prompt
-        formatted_input = f"Question: {system_prompt} {user_input} Mini:"
-
-        # Encode the formatted input using the tokenizer
-        user_input_ids = tokenizer.encode(formatted_input, return_tensors="pt")
-
-        # Generate a response using the PEFT model
-        response = peft_model.generate(input_ids=user_input_ids, max_length=512, pad_token_id=tokenizer.eos_token_id)
+# Load the Falcon model with the specified configuration
+falcon_model = AutoModelForCausalLM.from_pretrained("tiiuae/falcon-7b-instruct")
+
+# Class to encapsulate the Falcon chatbot
+class FalconChatBot:
+    def __init__(self, system_prompt="You are an expert medical analyst:"):
+        self.system_prompt = system_prompt
+
+    def process_history(self, history):
+        # Filter out special commands from the history
+        filtered_history = []
+        for message in history:
+            user_message = message["user"]
+            assistant_message = message["assistant"]
+            # Check if the user_message is not a special command
+            if not user_message.startswith("Falcon:"):
+                filtered_history.append({"user": user_message, "assistant": assistant_message})
+        return filtered_history
+
+    def predict(self, input_data, max_length=500):
+        # Extract messages from the input data
+        preprompt = input_data["preprompt"]
+        history = input_data["history"]
+
+        # Process the history to remove special commands
+        processed_history = self.process_history(history)
+
+        # Generate the formatted conversation in Falcon message format
+        conversation = f"{preprompt}\n"
+        for message in processed_history:
+            user_message = message["user"]
+            assistant_message = message["assistant"]
+            conversation += f"User: {user_message}\nFalcon:{' ' + assistant_message if assistant_message else ''}\n"
+
+        # Encode the formatted conversation using the tokenizer
+        input_ids = tokenizer.encode(conversation, return_tensors="pt", add_special_tokens=False)
+
+        # Generate a response using the Falcon model
+        response = falcon_model.generate(input_ids, max_length=max_length, use_cache=True, early_stopping=True, bos_token_id=falcon_model.config.bos_token_id, eos_token_id=falcon_model.config.eos_token_id, pad_token_id=falcon_model.config.eos_token_id, temperature=0.1, do_sample=True)
 
         # Decode the generated response to text
         response_text = tokenizer.decode(response[0], skip_special_tokens=True)
-        
-        return response_text  # Return the generated response
 
-bot = ChatBot()
-
-title = "👋🏻Welcome to Tonic's GaiaMiniMed Chat🚀"
-description = "You can use this Space to test out the current model [(Tonic/GaiaMiniMed)](https://huggingface.co/Tonic/GaiaMiniMed) or duplicate this Space and use it locally or on 🤗HuggingFace. [Join me on Discord to build together](https://discord.gg/VqTxc76K3u)."
-examples = [["What is the proper treatment for buccal herpes?", "You are a medicine and public health expert, you will receive a question, answer the question, and provide a complete answer"]]
+        return response_text
+
+# Create the Falcon chatbot instance
+falcon_bot = FalconChatBot()
+
+# Define the Gradio interface
+title = "👋🏻Welcome to Falcon's Medical Expert Chat🚀"
+description = "You can use this Space to test out the Falcon model [(tiiuae/falcon-7b-instruct)](https://huggingface.co/tiiuae/falcon-7b-instruct) or duplicate this Space and use it locally or on 🤗HuggingFace. [Join me on Discord to build together](https://discord.gg/VqTxc76K3u)."
+examples = [{
+    "preprompt": "system message",
+    "history": [{
+        "user": "user message 1",
+        "assistant": "assistant message 1"
+    }, {
+        "user": "user message 1",
+        "assistant": None
+    }]
+}]
 
 iface = gr.Interface(
-    fn=bot.predict,
+    fn=falcon_bot.predict,
     title=title,
     description=description,
     examples=examples,
-    inputs=["text", "text"],  # Take user input and system prompt separately
+    inputs=[
+        gr.inputs.Textbox(label="Input Data", type="json),
+    ],
     outputs="text",
     theme="ParityError/Anime"
 )
 
+# Launch the Gradio interface for the Falcon model
 iface.launch()
+
 ```
 
 ## Training Details