Merge branch 'main' into Estelle

.cache/init.txt

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

Documentation.md

@@ -4,47 +4,134 @@ L'objectif du projet est de mettre en place une <strong>plateforme de requête</
 
 # Une description du système ou des données auxquelles l’interface permet d’accéder
 
+## Les Données 💾
 
 Le projet utilisera pour l'entraînement du modèle de langue le corpus issu de 'Newsroom: A Dataset of 1.3 Million Summaries with Diverse Extractive Strategies' (Grusky et al., NAACL 2018) newsroom assemblé par Max Grusky et ses collègues en 2018. Newsroom est un corpus parallèle rassemblant 1,3 millions articles de presse et leur résumé en anglais. Les résumés sont réalisés en utilisant les méthodes d'extraction comme d'abstraction ainsi que des méthodes mixtes. Ce corpus est disponible sur HuggingFace mais necessite un téléchargement préalable pour des raisons de protection des données.
 
+Le corpus est nettoyé avant d'être utilisé pour l'entraînement du LSTM. Seule les parties 'text' et 'summary' du jsonl sont utilisées.
+
+## Le système 🖥️
+
+2 systèmes :
+- LSTM réalisé à partir du <a href="https://loicgrobol.github.io//neural-networks/slides/03-transformers/transformers-slides.py.ipynb">cours</a> et de cet <a href="https://www.kaggle.com/code/columbine/seq2seq-pytorch">exemple</a> et de beaucoup d'autres référence en ligne.
+- Fine-tuned transformers
 
 # La méthodologie
 
-## Répartition du travail
-Nous avons décidé de travailler avec le logiciel de gestion de version Github en mettant en place un système de verification des commit avec un pull request.
-Cette méthode permet à chaque participant du projet d'observer les modifications effectuées par les autres membres avant d'accepter de fondre en une seule les branches main et les modifications proposées.
+## Répartition du travail 👥
+Nous avons travaillé avec le logiciel de gestion de version Github en mettant en place une intégration continue envoyant directement les `pull request` sur l'espace Huggingface.
+
+Idéalement, les `pull request` doivent être validées par deux membres du projet avant d'être accéptées afin d'éviter les erreurs en production. Nous n'avons pas mis en place ces restrictions à cause de la difficulté à gérer Docker dans Huggingface qui nous a nécessité beaucoup de modification.
 
 ## Problèmes rencontrés et résolution
-- Problème Mojibake depuis les fichiers jsonl : encodage en cp1252 et decodage en utf-8 avec ignore pour éviter les erreurs sur les caractères utf-8 présents dans le fichier à l'encodage
-- Répétition des mots à cause de la ponctuation : suppresion de la ponctuation avec `strip`
-- Agglomération des pronoms et des verbes : remplacement des `'` par des espaces avant le `split`
-- Split des noms propres composés ('Ivory Coast', 'Inter Milan') :
-- Problème des mots non disponibles dans le vocabulaire
-- Problème de la qualité du corpus :
-    - Résumés tronqués : "Did', 'Tatum', "O'Neal's", 'latest', 'battle', 'with', 'ex-husband', 'John', 'McEnroe', 'put', 'her', 'back', 'on', 'drugs?', 'The', '"Paper', 'Moon"star', 'checked', 'herself', 'into', "L.A.'s", 'Promises', 'rehab', 'facility', 'after', 'a', 'friend', 'caught', 'her', 'smoking', 'crack,', 'according', 'to', 'The', 'National', 'Enquirer.', "O'Neal", 'emerged', 'clean', 'and', 'sober', 'from', "Promises'", '34-day', 'recovery', 'program', 'in', 'late', 'July,', 'the', 'tab', 'reports.', 'The', 'actress', 'is', 'said', 'to', 'have', 'plunged', 'into', 'her', 'old', 'habits', 'because', 'of'"
-    - Résumés plus proche de titres que de résumés
-- Prise en compte du padding dans l'apprentissage --> utilisation de la fonctionnalité ignore_index de NLLLoss avec un padding d'une valeur à -100
+
+### Problème sur le corpus 📚
+
+- [x] Problème Mojibake depuis les fichiers jsonl :
+    - [x] encodage en cp1252 et decodage en utf-8 avec ignore pour éviter les erreurs sur les caractères utf-8 présents dans le fichier à l'encodage
+    - ❔Le problème ne se présente étrangement pas sur toutes les machines.
+- [x] Agglomération des pronoms et des verbes
+    - D'abord remplacement des `'` par des espaces avant le `split`
+    - Utilisation d'un dictionnaire de correspondance
+- [ ] Split des noms propres composés ('Ivory Coast', 'Inter Milan') :
+    - [ ] pas de résolution à ce jour
+- [ ] Problème des mots non disponibles dans le vocabulaire
+    - À terme, entraînement sur tout le corpus ?
+- [ ] Problème de la qualité du corpus :
+    - Résumés tronqués : "Did Tatum O'Neal's latest battle with ex-husband John McEnroe put her back on drugs? The \"Paper Moon\"star checked herself into L.A.'s Promises rehab facility after a friend caught her smoking crack, according to The National Enquirer. O'Neal emerged clean and sober from Promises' 34-day recovery program in late July, the tab reports. The actress is said to have plunged into her old habits because of" ...
+    - Résumés plus proche de titres que de résumés : "SAN DIEGO PADRES team notebook"
+    - [ ] pas de résolution à ce jour
+
+### Problème sur le Réseau de Neurone 🕸️
+
+- [x] Prise en compte du padding dans l'apprentissage :
+    - [ ] utilisation de la fonctionnalité ignore_index de NLLLoss avec un padding d'une valeur à -100
+- [ ] Temps d'apprentissage très long :
+    - [ ] essai de mise en place d'un entraînement par batch
+- [ ] Répetition des déterminants après entraînement du modèle - https://huggingface.co/blog/how-to-generate
+    - [x] mise en place d'un Beam Search - non fructueux
+    - [ ] Passage vers du Sampling
+
+### Problème sur le fine-tuning
+
+### Problème sur l'interface
+
+### Problème de l'Intégration continue
+
+- [x] Pas de lien possible entre Huggingface et un github dont l'history contient des fichier de plus de 10Mo
+    - 💣 Explosion du github
+- [ ] Docker qui fonctionne en local mais en sur Huggingface
+    - Problème de path de fichier
 
 
 ## Les étapes du projet
 
+1. Initialisation du Github
+2. Premiers pas dans le réseau de neurone
+3. Réalisation de la plateforme
+4. Intégration à Huggingface
+5. Fine-tuning de modèle
+6. Finalisation
+
 # Implémentation
 ## modélisation
 
-Nous avons décidé dans un premier temps de modéliser une LSTM pour le résuméautomatique sur labase du réseau de neurone réalisé en cours.
+Nous avons décidé dans un premier temps de modéliser une LSTM pour le résumé automatique sur la base du réseau de neurone réalisé en cours.
 Pour ce faire nous nous sommes beaucoup inspirée du kaggle https://www.kaggle.com/code/columbine/seq2seq-pytorch ainsi que de la documentation de PyTorch https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html#example-an-lstm-for-part-of-speech-tagging
+
 ## modules et API utilisés
+###  Dataloader :
+- Data
+```
+    A class used to get data from file
+    ...
+
+    Attributes
+    ----------
+    path : str
+        the path to the file containing the data
+
+    Methods
+    -------
+    open()
+        open the jsonl file with pandas
+    clean_data(text_type)
+        clean the data got by opening the file and adds <start> and
+        <end> tokens depending on the text_type
+    get_words()
+        get the dataset vocabulary
+```
+- Vectoriser
+```
+```
+
+### Model :
+
+### train :
+
+### inference :
+
+### api :
+
+### templates :
+
 ## Langages de programmation
+- 🐳 Docker
+- yaml
+- 🐍 et python evidemment
 
 # Les résultats (fichiers output, visualisations…)
 
 ## Les metriques d'évaluation
 - ROUGE
 - BLEU
-- QAEval
-- Meteor
-- BERTScore
 
 
 # Discussion des résultats
-ce que vous auriez aimé faire et ce que vous avez pu faire par exemple
+
+## Résultats du LSTM
+
+Les résultats du LSTM sont inutilisables mais ont permis au moins de se confronter à la difficulté de mettre en place des réseaux de neurones depuis pas grand chose.
+On aurait aimé avoir plus detemps pour aller plus loin et comprendre mieux encore : l'entraîement par batch, pourquoi les résultats sont si mauvais, mettre d'autres stratégies de génération en place, ...
+
+## Résultat du fine-tuning

api.py

@@ -1,169 +0,0 @@
-import re
-import uvicorn
-from fastapi import FastAPI, Form, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from src.inference import inferenceAPI
-from src.inference_t5 import inferenceAPI_t5
-
-
-def summarize(text: str):
-    """
-    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(inferenceAPI(text))
-        return re.sub("^1|1$|<start>|<end>", "", text)
-    elif global_choose_model.var == "fineTunedT5":
-        text = inferenceAPI_t5(text)
-        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 to send the css
-templates = Jinja2Templates(directory="templates")
-app.mount("/templates", StaticFiles(directory="templates"), name="templates")
-
-
-@app.get("/")
-async def index(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 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 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 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": model_error,
-                "model_list": model_list,
-                "selected_model": selected_model,
-            },
-        )
-    else:
-        global_choose_model(model_choice)
-        return templates.TemplateResponse(
-            "index.html.jinja",
-            {
-                "request": request,
-                "model_list": model_list,
-                "selected_model": selected_model,
-            },
-        )
-
-
-@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:
-        text_error = "Please enter your text."
-        return templates.TemplateResponse(
-            "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,
-                "model_list": model_list,
-                "selected_model": selected_model,
-            },
-        )
-
-
-# ------------------------------------------------------------------------------------
-
-
-# launch the server and reload it each time a change is saved
-if __name__ == "__main__":
-    uvicorn.run("api:app", port=8000, reload=True)

requirements.txt

@@ -1,14 +1,15 @@
+anyascii==0.3.1
 anyio==3.6.2
 certifi==2022.12.7
 charset-normalizer==3.1.0
 click==8.1.3
-fastapi==0.92.0
+contractions==0.1.73
+fastapi==0.94.0
 filelock==3.9.0
 h11==0.14.0
-huggingface-hub==0.13.1
+huggingface-hub==0.13.2
 idna==3.4
 Jinja2==3.1.2
-joblib==1.2.0
 MarkupSafe==2.1.2
 numpy==1.24.2
 nvidia-cublas-cu11==11.10.3.66
@@ -17,7 +18,8 @@ nvidia-cuda-runtime-cu11==11.7.99
 nvidia-cudnn-cu11==8.5.0.96
 packaging==23.0
 pandas==1.5.3
-pydantic==1.10.5
+pyahocorasick==2.0.0
+pydantic==1.10.6
 python-dateutil==2.8.2
 python-multipart==0.0.6
 pytz==2022.7.1
@@ -26,10 +28,12 @@ regex==2022.10.31
 requests==2.28.2
 six==1.16.0
 sniffio==1.3.0
-starlette==0.25.0
+starlette==0.26.1
+textsearch==0.0.24
 tokenizers==0.13.2
 torch==1.13.1
 tqdm==4.65.0
+transformers==4.26.1
 typing_extensions==4.5.0
 urllib3==1.26.15
-uvicorn==0.20.0
+uvicorn==0.21.0

src/api.py

@@ -0,0 +1,88 @@
+from fastapi import FastAPI, Form, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+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":
+        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 ---------------------------------------------------------------------
+app = FastAPI()
+
+# static files pour envoi du css au navigateur
+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})
+
+
+@app.get("/model")
+async def index(request: Request):
+    return templates.TemplateResponse("index.html.jinja", {"request": request})
+
+
+@app.get("/predict")
+async def index(request: Request):
+    return templates.TemplateResponse("index.html.jinja", {"request": request})
+
+
+@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."
+        return templates.TemplateResponse(
+            "index.html.jinja", {"request": request, "text": erreur_modele}
+        )
+    else:
+        choisir_modele(choixModel)
+        print("C'est bon on utilise le modèle demandé")
+        return templates.TemplateResponse("index.html.jinja", {"request": request})
+
+
+# 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)):
+    if not text:
+        error = "Merci de saisir votre texte."
+        return templates.TemplateResponse(
+            "index.html.jinja", {"request": request, "text": error}
+        )
+    else:
+        summary = summarize(text)
+        return templates.TemplateResponse(
+            "index.html.jinja", {"request": request, "text": text, "summary": summary}
+        )
+
+
+# ------------------------------------------------------------------------------------
+
+
+# lancer le serveur et le recharger a chaque modification sauvegardee
+# if __name__ == "__main__":
+#     uvicorn.run("api:app", port=8000, reload=True)

src/dataloader.py

@@ -38,8 +38,6 @@ class Data(torch.utils.data.Dataset):
         <end> tokens depending on the text_type
     get_words()
         get the dataset vocabulary
-    make_dataset()
-        create a dataset with cleaned data
     """
 
     def __init__(self, path: str, transform=None) -> None:
@@ -52,10 +50,15 @@ class Data(torch.utils.data.Dataset):
 
     def __getitem__(self, idx):
         row = self.data.iloc[idx]
-        text = row["text"].translate(str.maketrans("", "", string.punctuation)).split()
+        text = row["text"].translate(
+            str.maketrans(
+                "", "", string.punctuation)).split()
         summary = (
-            row["summary"].translate(str.maketrans("", "", string.punctuation)).split()
-        )
+            row["summary"].translate(
+                str.maketrans(
+                    "",
+                    "",
+                    string.punctuation)).split())
         summary = ["<start>", *summary, "<end>"]
         sample = {"text": text, "summary": summary}
 
@@ -106,7 +109,8 @@ class Data(torch.utils.data.Dataset):
             tokenized_texts.append(text)
 
         if text_type == "summary":
-            return [["<start>", *summary, "<end>"] for summary in tokenized_texts]
+            return [["<start>", *summary, "<end>"]
+                    for summary in tokenized_texts]
         return tokenized_texts
 
     def get_words(self) -> list:
@@ -157,8 +161,10 @@ class Vectoriser:
 
     def __init__(self, vocab=None) -> None:
         self.vocab = vocab
-        self.word_count = Counter(word.lower().strip(",.\\-") for word in self.vocab)
-        self.idx_to_token = sorted([t for t, c in self.word_count.items() if c > 1])
+        self.word_count = Counter(word.lower().strip(",.\\-")
+                                  for word in self.vocab)
+        self.idx_to_token = sorted(
+            [t for t, c in self.word_count.items() if c > 1])
         self.token_to_idx = {t: i for i, t in enumerate(self.idx_to_token)}
 
     def load(self, path):
@@ -167,7 +173,8 @@ class Vectoriser:
             self.word_count = Counter(
                 word.lower().strip(",.\\-") for word in self.vocab
             )
-            self.idx_to_token = sorted([t for t, c in self.word_count.items() if c > 1])
+            self.idx_to_token = sorted(
+                [t for t, c in self.word_count.items() if c > 1])
             self.token_to_idx = {t: i for i, t in enumerate(self.idx_to_token)}
 
     def save(self, path):

src/fine_tune_T5.py

@@ -0,0 +1,257 @@
+import os
+import re
+import string
+
+import contractions
+import datasets
+import evaluate
+import pandas as pd
+import torch
+from datasets import Dataset
+from tqdm import tqdm
+from transformers import (AutoConfig, AutoModelForSeq2SeqLM, AutoTokenizer,
+                          DataCollatorForSeq2Seq, Seq2SeqTrainer,
+                          Seq2SeqTrainingArguments)
+
+
+def clean_text(texts):
+    """This fonction makes clean text for the future use"""
+    texts = texts.lower()
+    texts = contractions.fix(texts)
+    texts = texts.translate(str.maketrans("", "", string.punctuation))
+    texts = re.sub(r"\n", " ", texts)
+    return texts
+
+
+def datasetmaker(path=str):
+    """This fonction take the jsonl file, read it to a dataframe,
+    remove the colums not needed for the task and turn it into a file type Dataset
+    """
+    data = pd.read_json(path, lines=True)
+    df = data.drop(
+        [
+            "url",
+            "archive",
+            "title",
+            "date",
+            "compression",
+            "coverage",
+            "density",
+            "compression_bin",
+            "coverage_bin",
+            "density_bin",
+        ],
+        axis=1,
+    )
+    tqdm.pandas()
+    df["text"] = df.text.apply(lambda texts: clean_text(texts))
+    df["summary"] = df.summary.apply(lambda summary: clean_text(summary))
+    dataset = Dataset.from_dict(df)
+    return dataset
+
+
+# voir si le model par hasard esr déjà bien
+
+# test_text = dataset['text'][0]
+# pipe = pipeline('summarization', model = model_ckpt)
+# pipe_out = pipe(test_text)
+# print(pipe_out[0]['summary_text'].replace('.<n>', '.\n'))
+# print(dataset['summary'][0])
+
+
+def generate_batch_sized_chunks(list_elements, batch_size):
+    """this fonction split the dataset into smaller batches
+    that we can process simultaneously
+    Yield successive batch-sized chunks from list_of_elements."""
+    for i in range(0, len(list_elements), batch_size):
+        yield list_elements[i: i + batch_size]
+
+
+def calculate_metric(dataset, metric, model, tokenizer,
+                     batch_size, device,
+                     column_text='text',
+                     column_summary='summary'):
+    """this fonction evaluate the model with metric rouge and
+    print a table of rouge scores rouge1', 'rouge2', 'rougeL', 'rougeLsum'"""
+
+    article_batches = list(
+        str(generate_batch_sized_chunks(dataset[column_text], batch_size))
+    )
+    target_batches = list(
+        str(generate_batch_sized_chunks(dataset[column_summary], batch_size))
+    )
+
+    for article_batch, target_batch in tqdm(
+        zip(article_batches, target_batches), total=len(article_batches)
+    ):
+        inputs = tokenizer(
+            article_batch,
+            max_length=1024,
+            truncation=True,
+            padding="max_length",
+            return_tensors="pt",
+        )
+        # parameter for length penalty ensures that the model does not
+        # generate sequences that are too long.
+        summaries = model.generate(
+            input_ids=inputs["input_ids"].to(device),
+            attention_mask=inputs["attention_mask"].to(device),
+            length_penalty=0.8,
+            num_beams=8,
+            max_length=128,
+        )
+
+        # Décode les textes
+        # renplacer les tokens, ajouter des textes décodés avec les rédéfences
+        # vers la métrique.
+        decoded_summaries = [
+            tokenizer.decode(
+                s, skip_special_tokens=True, clean_up_tokenization_spaces=True
+            )
+            for s in summaries
+        ]
+
+        decoded_summaries = [d.replace("", " ") for d in decoded_summaries]
+
+        metric.add_batch(
+            predictions=decoded_summaries,
+            references=target_batch)
+
+    # compute et return les ROUGE scores.
+    results = metric.compute()
+    rouge_names = ["rouge1", "rouge2", "rougeL", "rougeLsum"]
+    rouge_dict = dict((rn, results[rn]) for rn in rouge_names)
+    return pd.DataFrame(rouge_dict, index=["T5"])
+
+
+def convert_ex_to_features(example_batch):
+    """this fonction takes for input a list of inputExemples and convert to InputFeatures"""
+    input_encodings = tokenizer(example_batch['text'],
+                                max_length=1024, truncation=True)
+
+    labels = tokenizer(
+        example_batch["summary"],
+        max_length=128,
+        truncation=True)
+
+    return {
+        "input_ids": input_encodings["input_ids"],
+        "attention_mask": input_encodings["attention_mask"],
+        "labels": labels["input_ids"],
+    }
+
+
+if __name__ == '__main__':
+    # réalisation des datasets propres
+    train_dataset = datasetmaker('data/train_extract.jsonl')
+
+
+    test_dataset = datasetmaker("data/test_extract.jsonl")
+
+    test_dataset = datasetmaker('data/test_extract.jsonl')
+
+    dataset = datasets.DatasetDict({'train': train_dataset,
+                                    'dev': dev_dataset, 'test': test_dataset})
+    # 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')
+
+    mt5_config = AutoConfig.from_pretrained(
+        "google/mt5-small",
+        max_length=128,
+        length_penalty=0.6,
+        no_repeat_ngram_size=2,
+        num_beams=15,
+    )
+
+    model = (AutoModelForSeq2SeqLM
+             .from_pretrained('google/mt5-small', config=mt5_config)
+             .to(device))
+    #convertir les exemples en inputFeatures
+
+    dataset_pt = dataset.map(
+        convert_ex_to_features,
+        remove_columns=["summary", "text"],
+        batched=True,
+        batch_size=128,
+    )
+
+    data_collator = DataCollatorForSeq2Seq(
+        tokenizer, model=model, return_tensors="pt")
+    #définir les paramètres d'entrainement(fine tuning)
+    training_args = Seq2SeqTrainingArguments(
+        output_dir="t5_summary",
+        log_level="error",
+        num_train_epochs=10,
+        learning_rate=5e-4,
+        warmup_steps=0,
+        optim="adafactor",
+        weight_decay=0.01,
+        per_device_train_batch_size=2,
+        per_device_eval_batch_size=1,
+        gradient_accumulation_steps=16,
+        evaluation_strategy="steps",
+        eval_steps=100,
+        predict_with_generate=True,
+        generation_max_length=128,
+        save_steps=500,
+        logging_steps=10,
+        # push_to_hub = True
+    )
+    #donner au entraineur(trainer) le model
+    # et les éléments nécessaire pour l'entrainement
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        data_collator=data_collator,
+        # compute_metrics = calculate_metric,
+        train_dataset=dataset_pt["train"],
+        eval_dataset=dataset_pt["dev"].select(range(10)),
+        tokenizer=tokenizer,
+    )
+
+    trainer.train()
+    rouge_metric = evaluate.load("rouge")
+    #évluer ensuite le model selon les résultats d'entrainement
+    score = calculate_metric(
+        test_dataset,
+        rouge_metric,
+        trainer.model,
+        tokenizer,
+        batch_size=2,
+        device=device,
+        column_text="text",
+        column_summary="summary",
+    )
+    print(score)
+
+    # Fine Tuning terminés et à sauvgarder
+
+    # sauvegarder fine-tuned model à local
+    os.makedirs("t5_summary", exist_ok=True)
+    if hasattr(trainer.model, "module"):
+        trainer.model.module.save_pretrained("t5_summary")
+    else:
+        trainer.model.save_pretrained("t5_summary")
+    tokenizer.save_pretrained("t5_summary")
+
+    # faire appel au model en local
+    model = (AutoModelForSeq2SeqLM
+             .from_pretrained("t5_summary")
+             .to(device))
+
+
+    # mettre en usage : TEST
+
+    # gen_kwargs = {"length_penalty" : 0.8, "num_beams" : 8, "max_length" : 128}
+    # sample_text = dataset["test"][0]["text"]
+    # reference = dataset["test"][0]["summary"]
+    # pipe = pipeline("summarization", model='./summarization_t5')
+
+    # print("Text :")
+    # print(sample_text)
+    # print("\nReference Summary :")
+    # print(reference)
+    # print("\nModel Summary :")
+    # print(pipe(sample_text, **gen_kwargs)[0]["summary_text"])

src/fine_tune_t5.py

@@ -1,204 +0,0 @@
-import torch
-import datasets
-from datasets import Dataset, DatasetDict
-import pandas as pd
-from tqdm import tqdm
-import re
-import os
-import nltk
-import string
-import contractions
-from transformers import pipeline
-import evaluate
-from transformers import AutoModelForSeq2SeqLM, AutoTokenizer,AutoConfig
-from transformers import Seq2SeqTrainingArguments ,Seq2SeqTrainer
-from transformers import DataCollatorForSeq2Seq
-
-# cuda out of memory
-os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:200"
-
-nltk.download('stopwords')
-nltk.download('punkt')
-
-
-def clean_data(texts):
-    texts = texts.lower()
-    texts = contractions.fix(texts)
-    texts = texts.translate(str.maketrans("", "", string.punctuation))
-    texts = re.sub(r'\n',' ',texts)
-    return texts
-
-def datasetmaker (path=str):
-    data = pd.read_json(path, lines=True)
-    df = data.drop(['url','archive','title','date','compression','coverage','density','compression_bin','coverage_bin','density_bin'],axis=1)
-    tqdm.pandas()
-    df['text'] = df.text.apply(lambda texts : clean_data(texts))
-    df['summary'] = df.summary.apply(lambda summary : clean_data(summary))
-    # df['text'] = df['text'].map(str)
-    # df['summary'] = df['summary'].map(str)
-    dataset = Dataset.from_dict(df)
-    return dataset
-
-#voir si le model par hasard esr déjà bien
-
-# test_text = dataset['text'][0]
-# pipe = pipeline('summarization',model = model_ckpt)
-# pipe_out = pipe(test_text)
-# print (pipe_out[0]['summary_text'].replace('.<n>','.\n'))
-# print(dataset['summary'][0])
-
-def generate_batch_sized_chunks(list_elements, batch_size):
-    """split the dataset into smaller batches that we can process simultaneously
-    Yield successive batch-sized chunks from list_of_elements."""
-    for i in range(0, len(list_elements), batch_size):
-        yield list_elements[i : i + batch_size]
-
-def calculate_metric(dataset, metric, model, tokenizer,
-                               batch_size, device,
-                               column_text='text',
-                               column_summary='summary'):
-    article_batches = list(str(generate_batch_sized_chunks(dataset[column_text], batch_size)))
-    target_batches = list(str(generate_batch_sized_chunks(dataset[column_summary], batch_size)))
-
-    for article_batch, target_batch in tqdm(
-        zip(article_batches, target_batches), total=len(article_batches)):
-
-        inputs = tokenizer(article_batch, max_length=1024,  truncation=True,
-                        padding="max_length", return_tensors="pt")
-
-        summaries = model.generate(input_ids=inputs["input_ids"].to(device),
-                         attention_mask=inputs["attention_mask"].to(device),
-                         length_penalty=0.8, num_beams=8, max_length=128)
-        ''' parameter for length penalty ensures that the model does not generate sequences that are too long. '''
-
-        # Décode les textes
-        # renplacer les tokens, ajouter des textes décodés avec les rédéfences vers la métrique.
-        decoded_summaries = [tokenizer.decode(s, skip_special_tokens=True,
-                                clean_up_tokenization_spaces=True)
-               for s in summaries]
-
-        decoded_summaries = [d.replace("", " ") for d in decoded_summaries]
-
-
-        metric.add_batch(predictions=decoded_summaries, references=target_batch)
-
-    #compute et return les ROUGE scores.
-    results = metric.compute()
-    rouge_names = ['rouge1','rouge2','rougeL','rougeLsum']
-    rouge_dict = dict((rn, results[rn] ) for rn in rouge_names )
-    return pd.DataFrame(rouge_dict, index = ['T5'])
-
-
-def convert_ex_to_features(example_batch):
-    input_encodings = tokenizer(example_batch['text'],max_length = 1024,truncation = True)
-
-    labels =tokenizer(example_batch['summary'], max_length = 128, truncation = True )
-
-    return {
-        'input_ids' : input_encodings['input_ids'],
-        'attention_mask': input_encodings['attention_mask'],
-        'labels': labels['input_ids']
-    }
-
-if __name__=='__main__':
-
-    train_dataset = datasetmaker('data/train_extract_100.jsonl')
-
-    dev_dataset = datasetmaker('data/dev_extract_100.jsonl')
-
-    test_dataset = datasetmaker('data/test_extract_100.jsonl')
-
-    dataset = datasets.DatasetDict({'train':train_dataset,'dev':dev_dataset ,'test':test_dataset})
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-    tokenizer = AutoTokenizer.from_pretrained("google/mt5-small")
-    mt5_config = AutoConfig.from_pretrained(
-    "google/mt5-small",
-    max_length=128,
-    length_penalty=0.6,
-    no_repeat_ngram_size=2,
-    num_beams=15,
-    )
-    model = (AutoModelForSeq2SeqLM
-            .from_pretrained("google/mt5-small", config=mt5_config)
-            .to(device))
-
-    dataset_pt= dataset.map(convert_ex_to_features,remove_columns=["summary", "text"],batched = True,batch_size=128)
-
-    data_collator = DataCollatorForSeq2Seq(tokenizer, model=model,return_tensors="pt")
-
-
-    training_args = Seq2SeqTrainingArguments(
-        output_dir = "mt5_sum",
-        log_level = "error",
-        num_train_epochs = 10,
-        learning_rate = 5e-4,
-        #   lr_scheduler_type = "linear",
-        warmup_steps = 0,
-        optim = "adafactor",
-        weight_decay = 0.01,
-        per_device_train_batch_size = 2,
-        per_device_eval_batch_size = 1,
-        gradient_accumulation_steps = 16,
-        evaluation_strategy = "steps",
-        eval_steps = 100,
-        predict_with_generate=True,
-        generation_max_length = 128,
-        save_steps = 500,
-        logging_steps = 10,
-        # push_to_hub = True
-    )
-
-
-    trainer = Seq2SeqTrainer(
-        model = model,
-        args = training_args,
-        data_collator = data_collator,
-        # compute_metrics = calculate_metric,
-        train_dataset=dataset_pt['train'],
-        eval_dataset=dataset_pt['dev'].select(range(10)),
-        tokenizer = tokenizer,
-    )
-
-    trainer.train()
-    rouge_metric = evaluate.load("rouge")
-
-    score = calculate_metric(test_dataset, rouge_metric, trainer.model, tokenizer,
-                                batch_size=2, device=device,
-                                column_text='text',
-                                column_summary='summary')
-    print (score)
-
-
-    #Fine Tuning terminés et à sauvgarder
-
-
-
-    # save fine-tuned model in local
-    os.makedirs("./summarization_t5", exist_ok=True)
-    if hasattr(trainer.model, "module"):
-        trainer.model.module.save_pretrained("./summarization_t5")
-    else:
-        trainer.model.save_pretrained("./summarization_t5")
-    tokenizer.save_pretrained("./summarization_t5")
-    # load local model
-    model = (AutoModelForSeq2SeqLM
-            .from_pretrained("./summarization_t5")
-            .to(device))
-
-
-    # mettre en usage : TEST
-
-
-    # gen_kwargs = {"length_penalty": 0.8, "num_beams":8, "max_length": 128}
-    # sample_text = dataset["test"][0]["text"]
-    # reference = dataset["test"][0]["summary"]
-    # pipe = pipeline("summarization", model='./summarization_t5')
-
-    # print("Text:")
-    # print(sample_text)
-    # print("\nReference Summary:")
-    # print(reference)
-    # print("\nModel Summary:")
-    # print(pipe(sample_text, **gen_kwargs)[0]["summary_text"])

src/{inference.py → inference_lstm.py}

@@ -1,5 +1,6 @@
 """
  Allows to predict the summary for a given entry text
+ using LSTM model
 """
 import pickle
 
@@ -7,13 +8,14 @@ import torch
 
 from src import dataloader
 from src.model import Decoder, Encoder, EncoderDecoderModel
+# from transformers import AutoModel
 
 with open("model/vocab.pkl", "rb") as vocab:
     words = pickle.load(vocab)
 vectoriser = dataloader.Vectoriser(words)
 
 
-def inferenceAPI(text: str) -> str:
+def inference_lstm(text: str) -> str:
     """
     Predict the summary for an input text
     --------
@@ -34,6 +36,7 @@ def inferenceAPI(text: str) -> str:
 
     # On instancie le modèle
     model = EncoderDecoderModel(encoder, decoder, vectoriser, device)
+    # model = AutoModel.from_pretrained("EveSa/SummaryProject-LSTM")
 
     # model.load_state_dict(torch.load("model/model.pt", map_location=device))
     # model.eval()

src/inference_t5.py

@@ -1,23 +1,25 @@
 """
  Allows to predict the summary for a given entry text
 """
-import torch
-import nltk
-import contractions
 import re
 import string
-nltk.download('stopwords')
-nltk.download('punkt')
+import os
+os.environ['TRANSFORMERS_CACHE'] = './.cache'
+
+import contractions
+import torch
 from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 
-def clean_data(texts):
+
+def clean_text(texts: str) -> str:
     texts = texts.lower()
-    texts = contractions.fix(texts)
     texts = texts.translate(str.maketrans("", "", string.punctuation))
-    texts = re.sub(r'\n',' ',texts)
+    texts = re.sub(r"\n", " ", texts)
     return texts
 
-def inferenceAPI_t5(text: str) -> str:
+
+
+def inference_t5(text: str) -> str:
     """
     Predict the summary for an input text
     --------
@@ -28,38 +30,45 @@ def inferenceAPI_t5(text: str) -> str:
         str
             The summary for the input text
     """
-    # definition des parametres d'entree pour le modèle
-    text = clean_data(text)
-    device = torch.device("cpu" if torch.cuda.is_available() else "cpu")
-    tokenizer= (AutoTokenizer.from_pretrained("./summarization_t5"))
-    # chargement du modele local
+
+    # 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))
+    # load local model
     model = (AutoModelForSeq2SeqLM
-            .from_pretrained("./summarization_t5")
-            .to(device))
+             .from_pretrained("Linggg/t5_summary",use_auth_token=True)
+             .to(device))
+
+
     text_encoding = tokenizer(
         text,
         max_length=1024,
-        padding='max_length',
+        padding="max_length",
         truncation=True,
         return_attention_mask=True,
         add_special_tokens=True,
-        return_tensors='pt'
+        return_tensors="pt",
     )
     generated_ids = model.generate(
-        input_ids=text_encoding['input_ids'],
-        attention_mask=text_encoding['attention_mask'],
+        input_ids=text_encoding["input_ids"],
+        attention_mask=text_encoding["attention_mask"],
         max_length=128,
         num_beams=8,
         length_penalty=0.8,
-        early_stopping=True
+        early_stopping=True,
     )
 
     preds = [
-            tokenizer.decode(gen_id, skip_special_tokens=True, clean_up_tokenization_spaces=True)
-            for gen_id in generated_ids
+        tokenizer.decode(
+            gen_id, skip_special_tokens=True, clean_up_tokenization_spaces=True
+        )
+        for gen_id in generated_ids
     ]
     return "".join(preds)
 
-if __name__ == "__main__":
-     text = input('Entrez votre phrase à résumer : ')
-     print('summary:',inferenceAPI(text))
+
+# if __name__ == "__main__":
+#     text = input('Entrez votre phrase à résumer : ')
+#     print('summary:', inferenceAPI_T5(text))

src/model.py

@@ -25,7 +25,8 @@ class Encoder(torch.nn.Module):
         # on s'en servira pour les mots inconnus
         self.embeddings = torch.nn.Embedding(vocab_size, embeddings_dim)
         self.embeddings.to(device)
-        self.hidden = torch.nn.LSTM(embeddings_dim, hidden_size, dropout=dropout)
+        self.hidden = torch.nn.LSTM(
+            embeddings_dim, hidden_size, dropout=dropout)
         # Comme on va calculer la log-vraisemblance,
         # c'est le log-softmax qui nous intéresse
         self.dropout = torch.nn.Dropout(dropout)
@@ -61,7 +62,8 @@ class Decoder(torch.nn.Module):
         # on s'en servira pour les mots inconnus
         self.vocab_size = vocab_size
         self.embeddings = torch.nn.Embedding(vocab_size, embeddings_dim)
-        self.hidden = torch.nn.LSTM(embeddings_dim, hidden_size, dropout=dropout)
+        self.hidden = torch.nn.LSTM(
+            embeddings_dim, hidden_size, dropout=dropout)
         self.output = torch.nn.Linear(hidden_size, vocab_size)
         # Comme on va calculer la log-vraisemblance,
         # c'est le log-softmax qui nous intéresse
@@ -100,32 +102,36 @@ class EncoderDecoderModel(torch.nn.Module):
         # The ratio must be inferior to 1 to allow text compression
         assert summary_len < 1, f"number lesser than 1 expected, got {summary_len}"
 
-        target_len = int(
-            summary_len * source.shape[0]
-        )  # Expected summary length (in words)
-        target_vocab_size = self.decoder.vocab_size  # Word Embedding length
+        # Expected summary length (in words)
+        target_len = int(summary_len * source.shape[0])
+        # Word Embedding length
+        target_vocab_size = self.decoder.vocab_size
 
-        # Output of the right format (expected summmary length x word embedding length)
-        # filled with zeros. On each iteration, we will replace one of the row of this
-        # matrix with the choosen word embedding
+        # Output of the right format (expected summmary length x word
+        # embedding length) filled with zeros. On each iteration, we
+        # will replace one of the row of this matrix with the choosen
+        # word embedding
         outputs = torch.zeros(target_len, target_vocab_size)
 
-        # put the tensors on the device (useless if CPU bus very useful in case of GPU)
+        # put the tensors on the device (useless if CPU bus very useful in
+        # case of GPU)
         outputs.to(self.device)
         source.to(self.device)
 
-        # last hidden state of the encoder is used as the initial hidden state of the decoder
-        hidden, cell = self.encoder(source)  # Encode the input text
-        input = self.vectoriser.encode(
-            "<start>"
-        )  # Encode the first word of the summary
+        # last hidden state of the encoder is used
+        # as the initial hidden state of the decoder
+
+        # Encode the input text
+        hidden, cell = self.encoder(source)
+        # Encode the first word of the summary
+        input = self.vectoriser.encode("<start>")
 
         # put the tensors on the device
         hidden.to(self.device)
         cell.to(self.device)
         input.to(self.device)
 
-        ### BEAM SEARCH ###
+        #   BEAM SEARCH   #
         # If you wonder, b stands for better
         values = None
         b_outputs = torch.zeros(target_len, target_vocab_size).to(self.device)
@@ -134,14 +140,16 @@ class EncoderDecoderModel(torch.nn.Module):
         for i in range(1, target_len):
             # On va déterminer autant de mot que la taille du texte souhaité
             # insert input token embedding, previous hidden and previous cell states
-            # receive output tensor (predictions) and new hidden and cell states.
+            # receive output tensor (predictions) and new hidden and cell
+            # states.
 
             # replace predictions in a tensor holding predictions for each token
             # logging.debug(f"output : {output}")
 
             ####### DÉBUT DU BEAM SEARCH ##########
             if values is None:
-                # On calcule une première fois les premières probabilité de mot après <start>
+                # On calcule une première fois les premières probabilité de mot
+                # après <start>
                 output, hidden, cell = self.decoder(input, hidden, cell)
                 output.to(self.device)
                 b_hidden = hidden
@@ -152,7 +160,8 @@ class EncoderDecoderModel(torch.nn.Module):
                 values, indices = output.topk(num_beams, sorted=True)
 
             else:
-                # On instancie le dictionnaire qui contiendra les scores pour chaque possibilité
+                # On instancie le dictionnaire qui contiendra les scores pour
+                # chaque possibilité
                 scores = {}
 
                 # Pour chacune des meilleures valeurs, on va calculer l'output
@@ -160,7 +169,8 @@ class EncoderDecoderModel(torch.nn.Module):
                     indice.to(self.device)
 
                     # On calcule l'output
-                    b_output, b_hidden, b_cell = self.decoder(indice, b_hidden, b_cell)
+                    b_output, b_hidden, b_cell = self.decoder(
+                        indice, b_hidden, b_cell)
 
                     # On empêche le modèle de se répéter d'un mot sur l'autre en mettant
                     # de force la probabilité du mot précédent à 0
@@ -179,7 +189,8 @@ class EncoderDecoderModel(torch.nn.Module):
                 # Et du coup on rempli la place de i-1 à la place de i
                 b_outputs[i - 1] = b_output.to(self.device)
 
-                # On instancies nos nouvelles valeurs pour la prochaine itération
+                # On instancies nos nouvelles valeurs pour la prochaine
+                # itération
                 values, indices = b_output.topk(num_beams, sorted=True)
 
             ##################################

src/train.py

@@ -150,16 +150,24 @@ if __name__ == "__main__":
     words = train_dataset.get_words()
     vectoriser = dataloader.Vectoriser(words)
 
-    train_dataset = dataloader.Data("data/train_extract.jsonl", transform=vectoriser)
-    dev_dataset = dataloader.Data("data/dev_extract.jsonl", transform=vectoriser)
+    train_dataset = dataloader.Data(
+        "data/train_extract.jsonl",
+        transform=vectoriser)
+    dev_dataset = dataloader.Data(
+        "data/dev_extract.jsonl",
+        transform=vectoriser)
 
     train_dataloader = torch.utils.data.DataLoader(
-        train_dataset, batch_size=2, shuffle=True, collate_fn=dataloader.pad_collate
-    )
+        train_dataset,
+        batch_size=2,
+        shuffle=True,
+        collate_fn=dataloader.pad_collate)
 
     dev_dataloader = torch.utils.data.DataLoader(
-        dev_dataset, batch_size=4, shuffle=True, collate_fn=dataloader.pad_collate
-    )
+        dev_dataset,
+        batch_size=4,
+        shuffle=True,
+        collate_fn=dataloader.pad_collate)
 
     for i_batch, batch in enumerate(train_dataloader):
         print(i_batch, batch[0], batch[1])
@@ -169,7 +177,8 @@ if __name__ == "__main__":
     print("Device check. You are using:", device)
 
     ### RÉSEAU ENTRAÎNÉ ###
-    # Pour s'assurer que les résultats seront les mêmes à chaque run du notebook
+    # Pour s'assurer que les résultats seront les mêmes à chaque run du
+    # notebook
     torch.use_deterministic_algorithms(True)
     torch.manual_seed(0)
     random.seed(0)
@@ -178,9 +187,8 @@ if __name__ == "__main__":
     encoder = Encoder(len(vectoriser.idx_to_token) + 1, 256, 512, 0.5, device)
     decoder = Decoder(len(vectoriser.idx_to_token) + 1, 256, 512, 0.5, device)
 
-    trained_classifier = EncoderDecoderModel(encoder, decoder, vectoriser, device).to(
-        device
-    )
+    trained_classifier = EncoderDecoderModel(
+        encoder, decoder, vectoriser, device).to(device)
 
     print(next(trained_classifier.parameters()).device)
     # print(train_dataset.is_cuda)
@@ -194,7 +202,6 @@ if __name__ == "__main__":
 
     torch.save(trained_classifier.state_dict(), "model/model.pt")
     vectoriser.save("model/vocab.pkl")
-    trained_classifier.push_to_hub("SummaryProject-LSTM")
 
     print(f"test summary : {vectoriser.decode(dev_dataset[6][1])}")
     print(

templates/index.html.jinja

@@ -4,7 +4,8 @@
         <title>Text summarization API</title>
         <meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
-		<link rel="stylesheet" href="{{ url_for('templates', path='/site_style/css/main.css') }}" />
+		<style>html, body, div, h1, h2, p, blockquote,a, code, em, img, strong, u, ul, li,label, legend, caption, tr, th, td,header, menu, nav, section, summary{margin: 0;padding: 0;border: 0;font-size: 100%;font: inherit;vertical-align: baseline}header, menu, nav, section{display: block}div{margin-bottom: 20px}body{line-height: 1}ul{list-style: none}body{-webkit-text-size-adjust: none}input::-moz-focus-inner{border: 0;padding: 0}html{box-sizing: border-box}*, *:before, *:after{box-sizing: inherit}body{color: #5b5b5b;font-size: 15pt;line-height: 1.85em;font-family: 'Source Sans Pro', sans-serif;font-weight: 300;background-image: url("templates/site_style/images/background.jpg");background-size: cover;background-position: center center;background-attachment: fixed}h1, h2, h3{font-weight: 400;color: #483949;line-height: 1.25em}h1 a, h2 a, h3 a{color: inherit;text-decoration: none;border-bottom-color: transparent}h1 strong, h2 strong, h3 strong{font-weight: 600}h2{font-size: 2.85em}h3{font-size: 1.25em}strong, b{font-weight: 400;color: #483949}em, i{font-style: italic}a{color: inherit;border-bottom: solid 1px rgba(128, 128, 128, 0.15);text-decoration: none;-moz-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;-webkit-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;-ms-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out}a:hover{color: #ef8376;border-bottom-color: transparent}p, ul{margin-bottom: 1em}p{text-align: justify}hr{position: relative;display: block;border: 0;top: 4.5em;margin-bottom: 9em;height: 6px;border-top: solid 1px rgba(128, 128, 128, 0.2);border-bottom: solid 1px rgba(128, 128, 128, 0.2)}hr:before, hr:after{content: '';position: absolute;top: -8px;display: block;width: 1px;height: 21px;background: rgba(128, 128, 128, 0.2)}hr:before{left: -1px}hr:after{right: -1px}ul{list-style: disc;padding-left: 1em}ul li{padding-left: 0.5em;font-size: 85%;list-style: none}textarea{border-radius: 10px;resize: none;padding: 10px;line-height: 20px;word-spacing: 1px;font-size: 16px;width: 85%;height: 100%}::-webkit-input-placeholder{font-size: 17px;word-spacing: 1px}table{width: 100%}table.default{width: 100%}table.default tbody tr:first-child{border-top: 0}table.default tbody tr:nth-child(2n 1){background: #fafafa}table.default th{text-align: left;font-weight: 400;padding: 0.5em 1em 0.5em 1em}input[type="button"],input[type="submit"],input[type="reset"],button,.button{position: relative;display: inline-block;background: #df7366;color: #fff;text-align: center;border-radius: 0.5em;text-decoration: none;padding: 0.65em 3em 0.65em 3em;border: 0;cursor: pointer;outline: 0;font-weight: 300;-moz-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;-webkit-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;-ms-transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out;transition: background-color 0.35s ease-in-out, color 0.35s ease-in-out, border-bottom-color 0.35s ease-in-out}input[type="button"]:hover,input[type="submit"]:hover,input[type="reset"]:hover,button:hover,.button:hover{color: #fff;background: #ef8376}input[type="button"].alt,input[type="submit"].alt,input[type="reset"].alt,button.alt,.button.alt{background: #2B252C}input[type="button"].alt:hover,input[type="submit"].alt:hover,input[type="reset"].alt:hover,button.alt:hover,.button.alt:hover{background: #3B353C}#header{position: relative;background-size: cover;background-position: center center;background-attachment: fixed;color: #fff;text-align: center;padding: 5em 0 2em 0;cursor: default;height: 100%}#header:before{content: '';display: inline-block;vertical-align: middle;height: 100%}#header .inner{position: relative;z-index: 1;margin: 0;display: inline-block;vertical-align: middle}#header header{display: inline-block}#header header > p{font-size: 1.25em;margin: 0}#header h1{color: #fff;font-size: 3em;line-height: 1em}#header h1 a{color: inherit}#header .button{display: inline-block;border-radius: 100%;width: 4.5em;height: 4.5em;line-height: 4.5em;text-align: center;font-size: 1.25em;padding: 0}#header hr{top: 1.5em;margin-bottom: 3em;border-bottom-color: rgba(192, 192, 192, 0.35);box-shadow: inset 0 1px 0 0 rgba(192, 192, 192, 0.35)}#header hr:before, #header hr:after{background: rgba(192, 192, 192, 0.35)}#nav{position: absolute;top: 0;left: 0;width: 100%;text-align: center;padding: 1.5em 0 1.5em 0;z-index: 1;overflow: hidden}#nav > hr{top: 0.5em;margin-bottom: 6em}.copyright{margin-top: 50px}@media screen and (max-width: 1680px){body, input, select{font-size: 14pt;line-height: 1.75em}}@media screen and (max-width: 1280px){body, input, select{font-size: 12pt;line-height: 1.5em}#header{background-attachment: scroll}#header .inner{padding-left: 2em;padding-right: 2em}}@media screen and (max-width: 840px){body, input, select{font-size: 13pt;line-height: 1.65em}}#navPanel, #titleBar{display: none}@media screen and (max-width: 736px){html, body{overflow-x: hidden}body, input, select{font-size: 12.5pt;line-height: 1.5em}h2{font-size: 1.75em}h3{font-size: 1.25em}hr{top: 3em;margin-bottom: 6em}#header{background-attachment: scroll;padding: 2.5em 0 0 0}#header .inner{padding-top: 1.5em;padding-left: 1em;padding-right: 1em}#header header > p{font-size: 1em}#header h1{font-size: 1.75em}#header hr{top: 1em;margin-bottom: 2.5em}#nav{display: none}#main > header{text-align: center}div.copyright{margin-top: 10px}label, textarea{font-size: 0.8rem;letter-spacing: 1px;font-family: Georgia, 'Times New Roman', Times, serif}.buttons{display: flex;flex-direction: row;justify-content: center;margin-top: 20px}}
+        </style>
         <script>
             function customReset()
             {