Synchronisation Pascal

.gitignore

@@ -0,0 +1 @@
+*.keras

README.md

@@ -0,0 +1,37 @@
+---
+title: SAE-GPT2
+emoji: ❤️
+colorFrom: indigo
+colorTo: red
+sdk: gradio
+sdk_version: 3.50.2
+app_file: app.py
+pinned: false
+---
+
+<hr/>
+
+<h4> Environnement de développement commun </h4>
+
+<br/>
+
+| Nom        | Lien                                                  |
+|------------|-------------------------------------------------------|
+| Production | https://huggingface.co/spaces/FFatih/SAE-GPT2-PROD    |
+| Recette    | https://huggingface.co/spaces/FFatih/SAE-GPT2-RECETTE |
+
+<hr/>
+
+<h4> Environnement de développement personnel </h4>
+
+<br/>
+
+| Prenom            | Lien                                                       |
+|-------------------|------------------------------------------------------------|
+| Fatih             | https://huggingface.co/spaces/FFatih/SAE-GPT2-FATIH        |
+| Bastien           | https://huggingface.co/spaces/BastienHot/SAE-GPT2-BASTIEN  |
+| Pascal            | https://huggingface.co/spaces/PascalZhan/SAE-GPT2-PASCAL   |
+| Tamij             | https://huggingface.co/spaces/Tamij/SAE-GPT2-TAMIJ         |
+| Kevin             | https://huggingface.co/spaces/Kemasu/SAE-GPT2-KEVIN        |
+| Lilian            | https://huggingface.co/spaces/Solialiranes/SAE-GPT2-LILIAN |
+| Evan              | https://huggingface.co/spaces/Evanparis240/SAE-GPT2-EVAN   |

app.py

@@ -0,0 +1,88 @@
+# Author: Bastien & Pascal
+# Date: 2/25/2024
+# Project: SAE-GPT2 | BUT 3 Informatique - Semester 5
+
+# Import of required libraries 
+import os
+
+os.system("pip install --upgrade pip")
+os.system("pip install googletrans-py")
+os.system("pip install tensorflow==2.15.0")
+os.system("pip install keras-nlp")
+os.system("pip install -q --upgrade keras") # Upgrade Keras to version 3
+
+import time
+import keras
+import keras_nlp
+import pandas as pd
+import gradio as gr
+from googletrans import Translator
+from importHuggingFaceHubModel import from_pretrained_keras
+
+# Set Keras Backend to Tensorflow
+os.environ["KERAS_BACKEND"] = "tensorflow"
+
+# Load the fine-tuned model
+#model = keras.models.load_model("LoRA_Model_V2.keras")
+model = from_pretrained_keras('DracolIA/GPT-2-LoRA-HealthCare')
+
+translator = Translator() # Create Translator Instance
+
+# Function to generate responses from the model
+def generate_responses(question):
+    language = translator.detect(question).lang.upper() # Verify the language of the prompt
+    if language != "EN":
+        question = translator.translate(question, src=language, dest="en").text # Translation of user text to english for the model
+        
+    prompt = f"[QUESTION] {question} [ANSWER]"
+    # Generate the answer from the model and then clean and extract the real model's response from the prompt engineered string
+    output = clean_answer_text(model.generate(prompt, max_length=1024))
+    
+    # Generate the answer from the model and then clean and extract the real model's response from the prompt engineered string
+    if language != "EN":
+        output = Translator().translate(output, src="en", dest=language).text # Translation of model's text to user's language
+    
+    return output
+
+# Function clean the output of the model from the prompt engineering done in the "generate_responses" function
+def clean_answer_text(text: str) -> str:
+    # Define the start marker for the model's response
+    response_start = text.find("[ANSWER]") + len("[ANSWER]")
+
+    # Extract everything after "Doctor:"
+    response_text = text[response_start:].strip()
+    last_dot_index = response_text.rfind(".")
+    if last_dot_index != -1:
+      response_text = response_text[:last_dot_index + 1]
+
+    # Additional cleaning if necessary (e.g., removing leading/trailing spaces or new lines)
+    response_text = response_text.strip()
+
+    return response_text
+    
+
+# Define a Gradio interface
+def chat_interface(question, history_df):
+    response = generate_responses(question)
+    # Insert the new question and response at the beginning of the DataFrame
+    history_df = pd.concat([pd.DataFrame({"Question": [question], "Réponse": [response]}), history_df], ignore_index=True)
+    return response, history_df
+
+with gr.Blocks() as demo:
+    gr.HTML("""
+        <div style='width: 100%; height: 200px; background: url("https://github.com/BastienHot/SAE-GPT2/raw/70fb88500a2cc168d71e8ed635fc54492beb6241/image/logo.png") no-repeat center center; background-size: contain;'>
+            <h1 style='text-align:center; width=100%'>DracolIA - AI Question Answering for Healthcare</h1>
+        </div>
+    """)
+    with gr.Row():
+        question = gr.Textbox(label="Votre Question", placeholder="Saisissez ici...")
+        submit_btn = gr.Button("Envoyer")
+    response = gr.Textbox(label="Réponse", interactive=False)
+    
+    # Initialize an empty DataFrame to keep track of question-answer history
+    history_display = gr.Dataframe(headers=["Question", "Réponse"], values=[], interactive=False)
+
+    submit_btn.click(fn=chat_interface, inputs=[question, history_display], outputs=[response, history_display])
+
+if __name__ == "__main__":
+    demo.launch()

importHuggingFaceHubModel.py

@@ -0,0 +1,164 @@
+# Author : ZHAN Pascal
+# Date 09/03/2025
+# Project: SAE-GPT2 | BUT 3 Informatique - Semester 5
+
+"""
+https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/keras_mixin.py#L397
+It seems the function 'from_pretrained_keras' from Hugging Face's 'huggingface_hub' is not working.
+Let's rewrite the code to fix it locally.
+
+To load the model, it's using 'tf.keras.models.load_model', but it's providing a folder instead of the path to the model file
+So, we'll search for the first file with the .keras extension in the folder. If None is found then it will raise an error.
+"""
+
+from huggingface_hub import ModelHubMixin, snapshot_download
+import os
+from huggingface_hub.utils import (
+    get_tf_version,
+    is_tf_available,
+)
+
+def from_pretrained_keras(*args, **kwargs) -> "KerasModelHubMixin":
+    r"""
+    Instantiate a pretrained Keras model from a pre-trained model from the Hub.
+    The model is expected to be in `SavedModel` format.
+    Args:
+        pretrained_model_name_or_path (`str` or `os.PathLike`):
+            Can be either:
+                - A string, the `model id` of a pretrained model hosted inside a
+                  model repo on huggingface.co. Valid model ids can be located
+                  at the root-level, like `bert-base-uncased`, or namespaced
+                  under a user or organization name, like
+                  `dbmdz/bert-base-german-cased`.
+                - You can add `revision` by appending `@` at the end of model_id
+                  simply like this: `dbmdz/bert-base-german-cased@main` Revision
+                  is the specific model version to use. It can be a branch name,
+                  a tag name, or a commit id, since we use a git-based system
+                  for storing models and other artifacts on huggingface.co, so
+                  `revision` can be any identifier allowed by git.
+                - A path to a `directory` containing model weights saved using
+                  [`~transformers.PreTrainedModel.save_pretrained`], e.g.,
+                  `./my_model_directory/`.
+                - `None` if you are both providing the configuration and state
+                  dictionary (resp. with keyword arguments `config` and
+                  `state_dict`).
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether to force the (re-)download of the model weights and
+            configuration files, overriding the cached versions if they exist.
+        resume_download (`bool`, *optional*, defaults to `False`):
+            Whether to delete incompletely received files. Will attempt to
+            resume the download if such a file exists.
+        proxies (`Dict[str, str]`, *optional*):
+            A dictionary of proxy servers to use by protocol or endpoint, e.g.,
+            `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The
+            proxies are used on each request.
+        token (`str` or `bool`, *optional*):
+            The token to use as HTTP bearer authorization for remote files. If
+            `True`, will use the token generated when running `transformers-cli
+            login` (stored in `~/.huggingface`).
+        cache_dir (`Union[str, os.PathLike]`, *optional*):
+            Path to a directory in which a downloaded pretrained model
+            configuration should be cached if the standard cache should not be
+            used.
+        local_files_only(`bool`, *optional*, defaults to `False`):
+            Whether to only look at local files (i.e., do not try to download
+            the model).
+        model_kwargs (`Dict`, *optional*):
+            model_kwargs will be passed to the model during initialization
+    <Tip>
+    Passing `token=True` is required when you want to use a private
+    model.
+    </Tip>
+    """
+    return KerasModelHubMixin.from_pretrained(*args, **kwargs)
+
+
+class KerasModelHubMixin(ModelHubMixin):
+    """
+    Implementation of [`ModelHubMixin`] to provide model Hub upload/download
+    capabilities to Keras models.
+    ```python
+    >>> import tensorflow as tf
+    >>> from huggingface_hub import KerasModelHubMixin
+    >>> class MyModel(tf.keras.Model, KerasModelHubMixin):
+    ...     def __init__(self, **kwargs):
+    ...         super().__init__()
+    ...         self.config = kwargs.pop("config", None)
+    ...         self.dummy_inputs = ...
+    ...         self.layer = ...
+    ...     def call(self, *args):
+    ...         return ...
+    >>> # Initialize and compile the model as you normally would
+    >>> model = MyModel()
+    >>> model.compile(...)
+    >>> # Build the graph by training it or passing dummy inputs
+    >>> _ = model(model.dummy_inputs)
+    >>> # Save model weights to local directory
+    >>> model.save_pretrained("my-awesome-model")
+    >>> # Push model weights to the Hub
+    >>> model.push_to_hub("my-awesome-model")
+    >>> # Download and initialize weights from the Hub
+    >>> model = MyModel.from_pretrained("username/super-cool-model")
+    ```
+    """
+
+    @classmethod
+    def _from_pretrained(
+        cls,
+        model_id,
+        revision,
+        cache_dir,
+        force_download,
+        proxies,
+        resume_download,
+        local_files_only,
+        token,
+        **model_kwargs,
+    ):
+        """Here we just call [`from_pretrained_keras`] function so both the mixin and
+        functional APIs stay in sync.
+                TODO - Some args above aren't used since we are calling
+                snapshot_download instead of hf_hub_download.
+        """
+        if is_tf_available():
+            import tensorflow as tf
+        else:
+            raise ImportError("Called a TensorFlow-specific function but could not import it.")
+
+        # TODO - Figure out what to do about these config values. Config is not going to be needed to load model
+        cfg = model_kwargs.pop("config", None)
+
+        # Root is either a local filepath matching model_id or a cached snapshot
+        if not os.path.isdir(model_id):
+            storage_folder = snapshot_download(
+                repo_id=model_id,
+                revision=revision,
+                cache_dir=cache_dir,
+                library_name="keras",
+                library_version=get_tf_version(),
+            )
+        else:
+            storage_folder = model_id
+
+        files = os.listdir(storage_folder)
+        modelFileName = None
+        nbModel = 0
+        for file in files :
+          if file.endswith(".keras"):
+            modelFileName = file
+            nbModel +=1
+        
+        if modelFileName==None:
+          raise ValueError("Repository does not have model that ends with .keras!!!")
+
+        if nbModel > 1:
+          raise ValueError("Too many models!!!")
+
+        modelPath = storage_folder + '/' + modelFileName
+
+        model = tf.keras.models.load_model(modelPath, **model_kwargs)
+
+        # For now, we add a new attribute, config, to store the config loaded from the hub/a local dir.
+        model.config = cfg
+        
+        return model

requirements.txt

@@ -0,0 +1 @@
+gradio