fix api problem and tokent auth

.cache/init.txt

@@ -1 +0,0 @@
-initial

Dockerfile

@@ -6,6 +6,18 @@ COPY requirements.txt .
 
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
 COPY . .
 
 CMD ["uvicorn", "src.api:app", "--host", "0.0.0.0", "--port", "7860"]

src/api.py

@@ -1,82 +1,162 @@
 from fastapi import FastAPI, Form, Request
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
+import re
+
 
 from src.inference_lstm import inference_lstm
 from src.inference_t5 import inference_t5
 
 
-# ------ INFERENCE MODEL --------------------------------------------------------------
-# appel de la fonction inference, adaptee pour une entree txt
 def summarize(text: str):
-    if choisir_modele.var == "lstm":
-        return " ".join(inference_lstm(text))
-    elif choisir_modele.var == "fineTunedT5":
+    """
+    Returns the summary of an input text.
+    Parameter
+    ---------
+    text : str
+        A text to summarize.
+    Returns
+    -------
+    :str
+        The summary of the input text.
+    """
+    if global_choose_model.var == "lstm":
+        text = " ".join(inference_lstm(text))
+        return re.sub("^1|1$|<start>|<end>", "", text)
+    elif global_choose_model.var == "fineTunedT5":
         text = inference_t5(text)
-
-
-# ----------------------------------------------------------------------------------
-
-
-def choisir_modele(choixModele):
-    print("ON A RECUP LE CHOIX MODELE")
-    if choixModele == "lstm":
-        choisir_modele.var = "lstm"
-    elif choixModele == "fineTunedT5":
-        choisir_modele.var = "fineTunedT5"
-    else:
-        "le modele n'est pas defini"
-
-
-# -------- API ---------------------------------------------------------------------
+        return re.sub("<extra_id_0> ", "", text)
+    elif global_choose_model.var == "":
+        return "You have not chosen a model."
+
+
+def global_choose_model(model_choice):
+    """This function allows to connect the choice of the
+    model and the summary function by defining global variables.
+    The aime is to access a variable outside of a function."""
+    if model_choice == "lstm":
+        global_choose_model.var = "lstm"
+    elif model_choice == "fineTunedT5":
+        global_choose_model.var = "fineTunedT5"
+    elif model_choice == "  ---  ":
+        global_choose_model.var = ""
+
+
+# definition of the main elements used in the script
+model_list = [
+    {"model": "  ---  ", "name": "  ---  "},
+    {"model": "lstm", "name": "LSTM"},
+    {"model": "fineTunedT5", "name": "Fine-tuned T5"},
+]
+selected_model = "  ---  "
+model_choice = ""
+
+
+# -------- API ---------------------------------------------------------------
 app = FastAPI()
 
-# static files pour envoi du css au navigateur
+# static files to send the css
 templates = Jinja2Templates(directory="templates")
 app.mount("/templates", StaticFiles(directory="templates"), name="templates")
 
 
 @app.get("/")
 async def index(request: Request):
-    return templates.TemplateResponse("index.html.jinja", {"request": request})
+    """This function is used to create an endpoint for the
+    index page of the app."""
+    return templates.TemplateResponse(
+        "index.html.jinja",
+        {
+            "request": request,
+            "current_route": "/",
+            "model_list": model_list,
+            "selected_model": selected_model,
+        },
+    )
 
 
 @app.get("/model")
-async def index(request: Request):
-    return templates.TemplateResponse("index.html.jinja", {"request": request})
+async def get_model(request: Request):
+    """This function is used to create an endpoint for
+    the model page of the app."""
+    return templates.TemplateResponse(
+        "index.html.jinja",
+        {
+            "request": request,
+            "current_route": "/model",
+            "model_list": model_list,
+            "selected_model": selected_model,
+        },
+    )
 
 
 @app.get("/predict")
-async def index(request: Request):
-    return templates.TemplateResponse("index.html.jinja", {"request": request})
+async def get_prediction(request: Request):
+    """This function is used to create an endpoint for
+    the predict page of the app."""
+    return templates.TemplateResponse(
+        "index.html.jinja", {"request": request, "current_route": "/predict"}
+    )
 
 
 @app.post("/model")
-async def choix_model(request: Request, choixModel: str = Form(None)):
-    print(choixModel)
-    if not choixModel:
-        erreur_modele = "Merci de saisir un modèle."
+async def choose_model(request: Request, model_choice: str = Form(None)):
+    """This functions allows to retrieve the model chosen by the user. Then, it
+    can end to an error message if it not defined or it is sent to the
+    global_choose_model function which connects the user choice to the
+    use of a model."""
+    selected_model = model_choice
+    # print(selected_model)
+    if not model_choice:
+        model_error = "Please select a model."
         return templates.TemplateResponse(
-            "index.html.jinja", {"request": request, "text": erreur_modele}
+            "index.html.jinja",
+            {
+                "request": request,
+                "text": model_error,
+                "model_list": model_list,
+                "selected_model": selected_model,
+            },
         )
     else:
-        choisir_modele(choixModel)
-        print("C'est bon on utilise le modèle demandé")
-        return templates.TemplateResponse("index.html.jinja", {"request": request})
+        global_choose_model(model_choice)
+        return templates.TemplateResponse(
+            "index.html.jinja",
+            {
+                "request": request,
+                "model_list": model_list,
+                "selected_model": selected_model,
+            },
+        )
 
 
-# retourner le texte, les predictions et message d'erreur si formulaire envoye vide
 @app.post("/predict")
 async def prediction(request: Request, text: str = Form(None)):
+    """This function allows to retrieve the input text of the user.
+    Then, it can end to an error message or it can be sent to
+    the summarize function."""
     if not text:
-        error = "Merci de saisir votre texte."
+        text_error = "Please enter your text."
         return templates.TemplateResponse(
-            "index.html.jinja", {"request": request, "text": error}
+            "index.html.jinja",
+            {
+                "request": request,
+                "text": text_error,
+                "model_list": model_list,
+                "selected_model": selected_model,
+            },
         )
     else:
         summary = summarize(text)
         return templates.TemplateResponse(
-            "index.html.jinja", {"request": request, "text": text, "summary": summary}
+            "index.html.jinja",
+            {
+                "request": request,
+                "text": text,
+                "summary": summary,
+                "model_list": model_list,
+                "selected_model": selected_model,
+            },
         )
 
 

src/fine_tune_T5.py

@@ -155,7 +155,9 @@ if __name__ == '__main__':
     # définition de device
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     # faire appel au model à entrainer
-    tokenizer = AutoTokenizer.from_pretrained('google/mt5-small')
+
+    hf_token = "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"
+    tokenizer = AutoTokenizer.from_pretrained('google/mt5-small', use_auth_token=hf_token )
 
     mt5_config = AutoConfig.from_pretrained(
         "google/mt5-small",
@@ -163,6 +165,7 @@ if __name__ == '__main__':
         length_penalty=0.6,
         no_repeat_ngram_size=2,
         num_beams=15,
+        use_auth_token=hf_token
     )
 
     model = (AutoModelForSeq2SeqLM
@@ -238,7 +241,7 @@ if __name__ == '__main__':
 
     # faire appel au model en local
     model = (AutoModelForSeq2SeqLM
-             .from_pretrained("t5_summary")
+             .from_pretrained("t5_summary", use_auth_token=hf_token )
              .to(device))
 
 

src/inference_t5.py

@@ -34,11 +34,11 @@ def inference_t5(text: str) -> str:
     # On défini les paramètres d'entrée pour le modèle
     text = clean_text(text)
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-    tokenizer = (AutoTokenizer.from_pretrained("Linggg/t5_summary",use_auth_token=True))
+    hf_token = "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"
+    tokenizer = AutoTokenizer.from_pretrained("Linggg/t5_summary", use_auth_token=hf_token )
     # load local model
     model = (AutoModelForSeq2SeqLM
-             .from_pretrained("Linggg/t5_summary",use_auth_token=True)
+             .from_pretrained("Linggg/t5_summary", use_auth_token = hf_token )
              .to(device))
 
 

templates/index.html.jinja

@@ -34,7 +34,7 @@
                     <select name="model_choice" class="selectModel" id="model_choice">
                         <!--A for jinja loop to retrieve option buttons from the api
                         and to keep them selected when a choice is made. -->
-                        {% for x in model_list%}
+                        {% for x in model_list %}
                             {%if selected_model == x.model%}
                                 <option value="{{x.model}}" selected>{{x.name}}</option>
                             {%else%}