add app files

deploy/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.7-slim-buster
+
+ENV REMOTEPORT 1091
+RUN pip install --upgrade pip
+
+RUN   useradd --create-home server
+
+USER server
+
+ENV PATH="/home/server/.local/bin:${PATH}"
+
+COPY --chown=server:server src src
+
+RUN pip install --user -r src/requirements.txt
+
+## Downloading Belgian GPT2 Model, in order to accelerate startup time
+RUN python -c "from transformers import GPT2Tokenizer; _ = GPT2Tokenizer.from_pretrained('antoiloui/belgpt2')"
+RUN python -c "from transformers import GPT2LMHeadModel; _ = GPT2LMHeadModel.from_pretrained('antoiloui/belgpt2')"
+
+## Running streamlit
+CMD streamlit run src/app.py --server.port $REMOTEPORT

src/app.py

@@ -0,0 +1,59 @@
+import streamlit as st
+from sampler import GPT2SentencesGenerator, SamplingSentencesGenerator, GreedySentencesGenerator, BeamSentencesGenerator
+import meta
+
+st.set_page_config(layout="wide")
+
+@st.cache(allow_output_mutation = True)
+def get_sentences_generator(method):
+    model_dir = "antoiloui/belgpt2"
+    if method =='sampling':
+        return SamplingSentencesGenerator(model_dir)
+    elif method == 'greedy':
+        return GreedySentencesGenerator(model_dir)
+    elif method == 'beam':
+        return BeamSentencesGenerator(model_dir)
+    else:
+        return NotImplementedError
+
+
+def display_parameters_from_generation_method(methode):
+    user_input = st.text_input('Texte de départ (peut être vide)', "les modèles génératifs sont cool !")
+    if methode == 'sampling':
+        user_nsamples = st.number_input("Nombre de phrases", min_value=1, max_value = 20)
+        user_temperature = st.slider("Choisissez une température : le degré de 'folie' du texte", min_value = 0.01, max_value = 1.5, value = 0.7)
+        user_top_k = st.slider(" TOP K : choisissez parmi les K mots les plus probables dans la génération",  min_value = 0, max_value = 1000, value=0)
+        user_top_p = st.slider(" TOP P : choisissez parmi le pourcentage des mots les plus probables dans la génération",  min_value = 0.5, max_value = 0.99, value = 0.9)
+        args_dict= {"contexte":user_input, "nsamples":user_nsamples, "temperature":user_temperature, "top_p":user_top_p, "top_k":user_top_k}
+    elif methode == 'greedy':
+        args_dict= {"contexte":user_input}
+    elif methode == 'beam':
+        user_num_beams = st.number_input("Nombre de faisceaux de probabilités", min_value = 2, max_value = 10)
+        user_nsamples = st.number_input("Nombre de phrases", min_value=1, max_value = 10)
+        args_dict= {"contexte":user_input, "num_beams":user_num_beams, "nsamples":user_nsamples}
+    else:
+       st.write("Les autres méthodes arrivent !!!")
+    return args_dict
+
+
+def display_principles():
+    for k,sentences in meta.body.items():
+        st.header(k)
+        for s in sentences:
+            st.write(s)
+
+def main():
+    st.title(meta.TITLE)
+    display_principles()
+    methode = st.selectbox("Choisissez votre méthode de génération", ['sampling', 'greedy', 'beam'])
+    generator = get_sentences_generator(methode)
+    st.header(f"Paramètres de la méthode __{methode}__")
+    args_dict = display_parameters_from_generation_method(methode)
+
+    if st.button('Parle, beau parleur !'):
+        res = generator.generate(**args_dict)
+        for texte in res:
+            st.write(texte)
+
+if __name__=='__main__':
+    main()

src/meta.py

@@ -0,0 +1,35 @@
+from collections import OrderedDict
+
+TITLE = "Beau parleur 🥖🥖🥖 : plateforme d'expérimentation de modèle génératif en langue française"
+
+HEADER1 = "Principes et objectifs"
+HEADER2 = "Méthodes de génération"
+HEADER3 = "Expérimentons ! "
+
+body = OrderedDict()
+
+body[HEADER1] = []
+body[HEADER1].append("Les modèles génératifs sur base des [Transformers](https://fr.wikipedia.org/wiki/Transformeur) ont permis une avancée notable en ce qui concerne la compréhension automatisée du langage. Ceci a permis des innovations de rupture dans plusieurs domaines, notamment dans la qualification de texte. Mais _quid_ du domaine créatif ? C'est ici qu'interviennent les modèles génératifs tels que [GPT](https://openai.com/blog/language-unsupervised/),[GPT-2](https://openai.com/blog/better-language-models/) ou encore le récent - et révolutionnaire - [GPT3](https://arxiv.org/abs/2005.14165).")
+
+body[HEADER1].append("Ces modèles sont pré-entraînés : ceci veut dire que les paramètres qui les déterminent ont déjà été appris par une grande volumétrie de données. Ainsi, libre à l'utilisateur de ce modèle de l'utiliser directement, ou bien de  _spécialiser_ le modèle en ajoutant une couche d'apprentissage supplémentaire (on parle alors de _fine-tuning_)")
+
+body[HEADER1].append("Ceci étant, les modèles génératifs sont biaisés en ce qui concerne les langues traitées. Ainsi, la donnée ayant servi à créer les modèles génératifs GPT est principalement de langue anglaise, ce qui peut avoir tendance à entraver l'adoption de l'intelligence artificielle dans le monde dans le monde.")
+
+
+body[HEADER1].append("La langue française n'est pas épargnée par une telle prépondérance de la langue anglaise. Notons néanmoins la remarquable initiative [PiaF](https://aclanthology.org/2020.lrec-1.673/), initiative issue de l'[EtaLab](https://www.etalab.gouv.fr/politique-de-la-donnee), plateforme gouvernementale de partage de la donnée.")
+
+body[HEADER1].append("Fort heureusement, la langue française ne se résume pas au territoire hexagonal ! Ainsi Antoine Louis a pré-entraîné un modèle GPT-2 sur près de 60Gb de donnée française et a mis à disposition ce modèle sur Hugging Face. Ce modèle se nomme [BelGPT-2](https://github.com/antoiloui/belgpt2), et c'est celui-ci que nous utiliserons.")
+
+
+body[HEADER2] = []
+body[HEADER2].append("Nous allons explorer 3 méthodes de génération. Les personnes intéressées pourront se référer au [post de blog de Hugging Face sur les modèles génératif](https://huggingface.co/blog/how-to-generate)")
+body[HEADER2].append("En bref, un modèle de type GPT2 est __auto-régressif__: conditionnellement à un mot que l'on prononce au sein d'une phrase, le modèle apprend à déterminer le mot suivant le plus probable.")
+
+body[HEADER2].append("Trois méthodes de générations sont possibles à partir de ce modèle")
+body[HEADER2].append(" - Une génération _greedy_ : les mots générés sont les mots les plus probables. Cette méthode n'a pas l'avantage de la diversité, car il n'en découle qu'un seul scénario possible.")
+body[HEADER2].append(" - Une génération par faisceaux, dite _beam search_ : les mots générés font partie d'une arborescence de mots les plus probables.")
+body[HEADER2].append(" - Une génération par échantillonage, ou une génération _sampling_ : On échantillone suivant la loi de probabilité calibrée par le modèle.")
+
+body[HEADER3] = []
+body[HEADER3].append("Il est grand temps d'expérimenter la génération et de se laisser entraîner par les différentes propositions")
+body[HEADER3].append("⚠️  Suivant les paramètres d'entrée, les textes générés peuvent être vulgaires, voire offensants. Ceux-ci peuvent être instructifs en ce qui concerne toxicité actuelle des discours sur Internet : en effet, la donnée sur laquelle ces modèles sont appris   ⚠️ ")

src/requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+torch
+transformers

src/sampler.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import argparse
+from transformers import CamembertTokenizerFast
+from transformers import  GPT2Config, GPT2LMHeadModel, GPT2Tokenizer
+from abc import abstractmethod
+from typing import List
+
+class GPT2SentencesGenerator():
+    """Abstract sentences GPT2 class, taking two inputs directly from Huffing Face directory: tokenizer and model"""
+    def __init__(self, model_dir):
+        self.tokenizer = GPT2Tokenizer.from_pretrained(model_dir)
+        self.model = GPT2LMHeadModel.from_pretrained(model_dir)
+
+    @abstractmethod
+    def generate(self):
+        """Abstract generative method""" 
+        pass
+
+    def decode(self, generated: List[int])-> List[str]:
+        """ Decode model output """
+        res = []
+        for v in generated:
+            res.append(self.tokenizer.decode(v, skip_special_tokens = True))
+        return res
+
+    def encode_context(self, contexte:str)->List[int]: 
+        """encodes prompt input with UTF8 handling""" 
+        utf8_contexte = contexte.encode("utf8").decode("utf8")
+        input_ids = self.tokenizer.encode(utf8_contexte, return_tensors = "pt")
+        return input_ids
+
+class GreedySentencesGenerator(GPT2SentencesGenerator):
+    def generate(self,  contexte:str)->List[str]:
+        """ Greedy output generation method """
+        input_ids = self.encode_context(contexte)
+        generated = self.model.generate(input_ids, do_sample = False)
+        return self.decode(generated)
+
+class BeamSentencesGenerator(GPT2SentencesGenerator):
+    def generate(self,  contexte:str, nsamples:int, num_beams:int)->List[str]:
+        """  """
+        input_ids = self.encode_context(contexte)
+        generated = self.model.generate(input_ids, do_sample = False, num_beams= num_beams, num_return_sequences = nsamples, early_stopping=True)
+        return self.decode(generated)
+
+class SamplingSentencesGenerator(GPT2SentencesGenerator):
+    def generate(self,  contexte:str, nsamples : int =10, temperature : int = 0.7,  top_p: float = 0.9, top_k : float =0)-> List[str]:
+        input_ids = self.encode_context(contexte)
+        generated = self.model.generate(
+        input_ids,
+        do_sample=True,
+        top_p = top_p,
+        top_k = top_k,
+        temperature =temperature,
+        num_return_sequences=nsamples,
+        repetition_penalty = 1.2, 
+        early_stopping = True)
+        return self.decode(generated)
+
+if __name__=='__main__':
+    parser = argparse.ArgumentParser()    
+    parser.add_argument("--contexte")
+    parser.add_argument("--model_dir")
+    parser.add_argument("--temperature", type = float, default = 0.7)
+    parser.add_argument("--tensors_type",  default = "pt")
+    parser.add_argument("--samples_output", default = "generated_sample.txt")
+    args = parser.parse_args()
+    g = SamplingSentencesGenerator(args.model_dir)
+    res = g.generate(args.contexte, nsamples = 5, temperature = args.temperature)
+    for v in res:
+        print(v)