Comprendre la rétention avec Gradio

Comprendre la rétention avec Gradio Tout ce que vous devez savoir

Comment tirer parti des applications Web pour l’analyse

Image de DALL-E 3

Je me souviens du moment où j’ai construit ma première application Web. C’était il y a environ huit ans et j’étais un analyste plutôt junior convaincu que les outils BI pouvaient résoudre tous les problèmes.

L’équipe d’ingénierie a construit un prototype d’un nouveau SDK et voulait savoir s’il collecte mieux les données. Ils l’ont testé sur un ensemble d’appareils, en examinant les données et en les comparant à l’ancienne version. Cependant, l’ensemble d’appareils changeait constamment, donc le maintenir à jour dans les outils BI nécessiterait beaucoup de travail. J’ai donc décidé de construire une application Web.

Je suis tombé sur un ensemble d’articles (une dizaine ou onze si je me souviens bien), je les ai tous lus et j’ai essayé d’utiliser ces connaissances pour ma tâche. Il m’a fallu environ une semaine pour terminer le premier prototype. J’ai dû écrire à la fois le côté back-end et le côté front-end, donc maintenant je pouvais me considérer au moins comme un développeur full-stack junior. Pour le back-end, j’ai utilisé Flask (j’ai eu de la chance de ne pas tomber sur Django, sinon j’aurais passé le mois entier), et pour le front-end — Bootstrap et Leaflet.

Dans l’ensemble, c’était une tâche difficile qui nécessitait beaucoup d’efforts pour se perfectionner en ingénierie. Je pense toujours que cela vaut la peine d’avoir une compréhension plus approfondie des autres domaines à côté de votre domaine d’expertise principal.

Cependant, je suis ravi qu’aujourd’hui, il existe de nombreux outils qui permettent aux analystes et aux scientifiques des données de construire des prototypes en moins d’une heure. Dans de nombreux cas, ces prototypes peuvent amener vos analyses au niveau supérieur. Voici quelques exemples :

  • Prévision des revenus et de l’audience en fonction des paramètres d’entrée (comme le budget marketing ou les marchés où nous allons lancer une nouvelle fonctionnalité),
  • Outils qui accéléreront le travail de votre équipe ou réduiront la charge de travail ad hoc, tels qu’un calculateur de test A/B ou une analyse automatique des causes profondes,
  • Solutions MVP, par exemple, si vous souhaitez utiliser LLMs pour automatiser certains processus internes, il est judicieux de tester un prototype avant de passer du temps sur une version de production. J’ai partagé un tel prototype ML dans l’un de mes articles précédents, “Construisez votre première application d’apprentissage en profondeur en une heure”.

Dans cet article, j’aimerais vous parler de l’un de ces frameworks qui peut vous aider à créer rapidement et presque sans effort des applications Web agréables à regarder sans vous soucier de JavaScript et CSS. Nous apprendrons les bases de Gradio, développerons quelques applications Web et les publierons sur HuggingFace Spaces afin que tout le monde puisse y accéder.

Gradio n’est pas le seul framework de ce genre. Il existe quelques autres alternatives Python open-source :

  • Streamlit est une autre bibliothèque populaire et puissante pour construire des applications de données avec peu de code. Il est également pris en charge par HuggingFace Spaces, vous pouvez donc héberger de telles applications.
  • Dash pourrait être pratique si vous êtes déjà habitué à Plotly, et il offre plus de possibilités de personnalisation.
  • Cependant, si vous voulez construire quelque chose de personnalisé et complexe, votre dernier recours serait Flask ou même Django.

Vous pouvez trouver plus de détails sur les principales fonctionnalités des différents frameworks dans cet article.

Les bases de Gradio

Gradio est une bibliothèque open-source en Python utilisée pour construire des applications interactives.

Les principaux avantages de Gradio sont :

  • vous pouvez construire des applications en utilisant uniquement Python, ce qui signifie également que vous pouvez utiliser toutes les bibliothèques Python dans votre application,
  • vous pouvez l’exécuter dans Jupyter Notebook ou en tant que page Web distincte,
  • vous pouvez héberger des applications Gradio en permanence sur HuggingFace Spaces.

Il n’y a pas de solution miracle, donc Gradio a ses limites :

  • Il est explicitement conçu pour les applications d’apprentissage automatique. Donc, si vous l’utilisez pour d’autres cas d’utilisation, vous devrez peut-être modifier les valeurs par défaut (par exemple, désactiver les signalements avec allow_flagging= "never").
  • La personnalisation est limitée, surtout en ce qui concerne le design.
  • Je tiens à souligner que Gradio est principalement un framework pour le prototypage rapide. Il fonctionne généralement bien, mais parfois, je rencontre un comportement étrange. Par exemple, l’édition de tableaux sur Safari fonctionne de manière contre-intuitive, ou parfois vous devez redémarrer Jupyter Notebook pour que l’interface se charge.

Pour commencer à utiliser Gradio, nous devons installer le package Python.

pip install gradio

En suivant la vieille tradition des programmeurs, commençons par un “Bonjour, le monde !”.

Nous pouvons utiliser la classe gr.Interface pour définir l’interface (documentation). C’est l’une des classes principales de Gradio qui vous aide à créer une application web basée sur n’importe quelle fonction Python.

Nous devons spécifier les paramètres suivants :

  • inputs: les composants d’entrée de l’interface (dans notre cas, juste un champ de texte),
  • outputs: les composants de sortie de l’interface (dans notre cas, également juste un champ de texte),
  • fn: la fonctionnalité principale (une fonction qui prend les entrées et renvoie les sorties, dans notre cas, elle prend le nom de l’entrée et renvoie “Bonjour, <nom> !”),
  • title & description: un peu de markdown pour rendre notre application plus conviviale.
import gradio as grdemo = gr.Interface(    inputs=[gr.Textbox(label="Nom", lines=1)],    outputs=[gr.Textbox(label="Résultat", lines=1)],    fn=lambda x: 'Bonjour, %s!' % x,    title="Bonjour, le monde !",    description="Votre première application utilisant Gradio",    allow_flagging='never')demo.launch()

Vous pouvez exécuter ce code dans votre Jupyter Notebook et voir les résultats. C’est assez pratique pour le débogage. Nous aborderons plus tard la manière de rendre votre application web accessible aux autres.

Image de l'auteur

C’est tout : juste quelques lignes de code, et votre première application Gradio fonctionne. De plus, je dois noter qu’elle a l’air assez belle et que nous n’avons pas eu besoin d’utiliser de magie frontale pour cela.

Gradio lance de nombreux processus en arrière-plan lorsque vous travaillez à partir de Jupyter Notebook, il vaut donc la peine de fermer les connexions de temps en temps à l’aide de gr.close_all().

Nous avons examiné l’exemple le plus basique et avons vu les éléments constitutifs de Gradio : les entrées, les sorties et les fonctions. Maintenant, nous sommes prêts à passer à des tâches analytiques réelles.

Simulation de croissance

Comme premier exemple, nous examinerons l’impact de la rétention sur la croissance des utilisateurs pour le produit.

La rétention comme base de la croissance

Deux paramètres définissent la croissance du produit :

  • acquisition (nombre de nouveaux utilisateurs chaque période),
  • rétention (capacité à conserver les clients dans le produit).

Modélisons comment la base d’utilisateurs va croître en fonction de la courbe de rétention.

Nous pouvons décrire n’importe quelle courbe de rétention à l’aide de la fonction suivante avec un ensemble de paramètres (a, b, c et d) :

Parlons du cas le plus courant de rétention : la cohorte est définie par la première action dans le produit, et toutes les actions sont prises en compte dans la rétention. Dans ce cas, la rétention pour périodes = 0 doit être égale à 1 (parce que l’entrée de la cohorte et les événements de rétention sont les mêmes). Ainsi, nous pouvons définir automatiquement l’un des paramètres :

Le principal facteur de croissance est la rétention à long terme. Cela détermine si les clients restent fidèles au produit pendant longtemps et si votre produit se développe de manière durable, ou si les clients se désengagent en un mois et que vous avez besoin d’acquérir de plus en plus de nouveaux utilisateurs pour la croissance. Dans notre formule, le paramètre a est responsable de la rétention à long terme.

Nous pouvons utiliser cette formule pour définir la courbe de rétention. Nous avons donc tout ce dont nous avons besoin pour passer au développement.

Visualisation du graphique de rétention

Commençons simplement et créons une application qui prendra les paramètres de la courbe de rétention et affichera la relation sous forme de graphique.

Tout comme notre exemple “Bonjour tout le monde”, nous devons utiliser la classe gr.Interface et passer les valeurs inputs, outputs et fn pour les mapper.

  • Nous avons maintenant besoin de plus de paramètres d’entrée. Donc, inputs sera une liste de contrôles. Nous utiliserons les contrôles gr.Slider et gr.Dropdown. Pour gr.Slider, nous devons passer des valeurs minimales, maximales, par défaut et une étiquette que nous utiliserons dans la fonction. Pour gr.Dropdown, nous devons définir une liste de valeurs possibles, une valeur par défaut et une étiquette.
  • Nous n’aurons toujours qu’une seule sortie – un graphique, donc outputs sera gr.Plot sans aucun paramètre.
  • La fonction fn mappera les entrées aux sorties, donc elle recevra les arguments d’entrée et renverra un objet plotly.Figure qui sera visualisé.
import plotly.express as px# fonctions pour calculer la rétentiondef get_retention(a, b, c, d, periods):    return  a + 1./(b + c * (periods ** d))def get_retention_same_event(a, c, d, periods):    b = 1./(1 - a)    return get_retention(a, b, c, d, periods)# définir la fonction - renvoyer un graphique en fonction des paramètres d'entréedef get_retention_plot(a, c, d, num_periods):    df = pd.DataFrame({'x': range(num_periods + 1)})    df['retention'] = df.x.map(lambda x: get_retention_same_event(a, c, d, x))    return px.line(df, x = 'x', y = 'retention',                   color_discrete_sequence = px.colors.qualitative.Prism,                   title = 'Courbe de rétention', labels = {'x': 'période'})# définir les entréesinputs = [    gr.Slider(0, 1, 0.03, label="a"),    gr.Slider(0, 5, 0.55, label="c"),    gr.Slider(0, 5, 1.5, label="d"),    gr.Dropdown([10, 30, 60, 90], value = 30, label="Nombre de périodes"),    gr.Dropdown([10, 100, 1000, 10000], value = 10000, label="Nombre de nouveaux utilisateurs chaque période")]# définir les sortiesoutputs = gr.Plot()# définir l'interfacedemo = gr.Interface(    fn=get_retention_plot,    inputs=inputs,    outputs=outputs,    cache_examples=True,    allow_flagging = 'never' # masquer la fonctionnalité de signalement par défaut dans l'interface)# lancerdemo.launch(debug = True)

Essayons de lancer cette application. Ça marche – nous pouvons voir un graphique qui change lorsque nous soumettons de nouveaux paramètres.

Ajout de plus de graphiques

Notre objectif était d’analyser l’impact de la rétention sur la croissance, nous devons donc ajouter des graphiques montrant non seulement la rétention, mais aussi l’audience au fil du temps. Modifions notre interface.

Pour simplifier, nous considérerons que chaque période voit le même nombre de nouveaux utilisateurs commencer à utiliser notre produit (paramètre cohort_size).

Nous devons apporter seulement quelques changements à notre implémentation :

  • Modifier la fonction get_retention_plot pour qu’elle reçoive un paramètre supplémentaire pour la taille de la cohorte, calcule le nombre d’utilisateurs au fil du temps et renvoie trois figures.
  • Le paramètre outputs est maintenant égal à la liste de trois objets gr.Plot().
def get_retention_plot(a, c, d, num_periods, cohort_size):    ret_df = pd.DataFrame({'x': range(num_periods + 1)})    ret_df['retention'] = ret_df.x.map(lambda x: get_retention_same_event(a, c, d, x))        ret_fig = px.line(ret_df.iloc[1:], x = 'x', y = 'retention',                       color_discrete_sequence = px.colors.qualitative.Prism,                       title = 'Courbe de rétention')    # simulation    tmp_data = []    for cohort in range(num_periods + 1):        for cohort_period in range(num_periods + 1):            period = cohort_period + cohort            if period > num_periods:                continue            retention = get_retention_same_event(a, c, d, cohort_period)            tmp_data.append(                {                    'cohort': 'cohort %s' % str(cohort).rjust(3, '0'),                    'cohort_period': cohort_period,                    'period': period,                    'retention': retention,                    'users': int(round(retention * cohort_size))                }            )    users_df = pd.DataFrame(tmp_data)    users_fig = px.area(users_df.groupby('period').users.sum(),                    color_discrete_sequence = px.colors.qualitative.Prism,                       title = 'Utilisateurs actifs')    cohorts_fig = px.area(users_df.pivot_table(index = 'period', columns = 'cohort', values = 'users',                    aggfunc = 'sum'),                    color_discrete_sequence = px.colors.qualitative.Prism,                     title = 'Utilisateurs actifs par cohorte')    return ret_fig, users_fig, cohorts_figinputs = [    gr.Slider(0, 1, 0.03, label="a"),    gr.Slider(0, 5, 0.55, label="c"),    gr.Slider(0, 5, 1.5, label="d"),    gr.Dropdown([10, 30, 60, 90], value = 30, label="Nombre de périodes"),    gr.Dropdown([10, 100, 1000, 10000], value = 10000, label="Nombre de nouveaux utilisateurs chaque période")]outputs = [gr.Plot(), gr.Plot(),  gr.Plot()]demo = gr.Interface(    fn=get_retention_plot,    inputs=inputs,    outputs=outputs,    allow_flagging = 'never',    cache_examples=True,)demo.launch(debug = True)

Fantastique, maintenant nous pouvons voir l’image complète et analyser les relations. Cependant, il y a de la place pour amélioration – nous pouvons ajouter du formatage pour rendre notre application plus pratique pour les utilisateurs.

Image par l'auteur

Ajouter un peu de style

Nous pouvons ajuster notre interface pour la rendre plus conviviale et plus simple.

Pour cela, nous utiliserons des gr.Blocks() en tant que contexte. Cette fonctionnalité permet de créer des applications web personnalisées et de définir des mises en page et des flux de données (des événements qui déclenchent des fonctions et leur exécution conséquente).

Les blocs nous ouvriront de nouvelles opportunités :

  • Avec gr.Blocks(), nous pouvons utiliser gr.Row() et gr.Column() pour organiser une mise en page.
  • gr.Markdown vous permet d’ajouter des éléments de texte en markdown, par exemple, des titres ou même du LaTeX avec des formules (par défaut, vous devez les mettre entre $).
  • gr.Accordion peut vous aider à masquer certains paramètres que vous ne voulez pas montrer à l’utilisateur par défaut.
  • De plus, cette approche permet de définir une logique de mise à jour plus complexe. Par exemple, mettre à jour les graphiques non seulement lorsque le bouton de soumission est cliqué, mais aussi lors de la modification de n’importe quel paramètre d’entrée. Nous utiliserons cette fonctionnalité dans l’exemple suivant.

En travaillant avec des blocs, nous devons définir chaque entrée et sortie en tant que variables, par exemple, a = gr.Slider(0, 1, 0.03, label=”a”).

De plus, il n’y a pas de contrôles par défaut, nous devons donc définir nous-mêmes les boutons – btn_caption = gr.Button(“Soumettre”).

L’action lors du clic sur le bouton doit également être spécifiée, en définissant les paramètres déjà connus – inputs, outputs et fn.

btn_caption.click(fn=get_retention_plot,         inputs=[a, c, d, num_periods, cohort_size],         outputs=[plot1, plot2, plot3])

Voici la version complète du code.

with gr.Blocks() as demo:    gr.Markdown("# Comprendre la croissance 🚀")    with gr.Row():        with gr.Column():            gr.Markdown("## Paramètres de la courbe de rétention 📈")            gr.Markdown(r"$\textbf{retention}(\textsf{x}) = \textsf{a} + \frac{\textsf{1}}{\textsf{b} + \textsf{c} * \textsf{x}^{\textsf{d}}}\ où\ \textsf{b} = \frac{\textsf{1}}{\textsf{1}-\textsf{a}}$")            with gr.Row():                a = gr.Slider(0, 1, 0.03, label="a")                c = gr.Slider(0, 5, 0.55, label="c")                d = gr.Slider(0, 5, 1.5, label="d")            with gr.Accordion("Plus d'options", open=False):                with gr.Row():                    num_periods = gr.Dropdown([10, 30, 60, 90], value = 30, label="Nombre de périodes")                    cohort_size = gr.Dropdown([10, 100, 1000, 10000], value = 10000, label="Nombre de nouveaux utilisateurs chaque période")            btn_caption = gr.Button("Soumettre")        with gr.Column():            plot1 = gr.Plot()    with gr.Row():        plot2 = gr.Plot()        plot3 = gr.Plot()        btn_caption.click(fn=get_retention_plot,         inputs=[a, c, d, num_periods, cohort_size],         outputs=[plot1, plot2, plot3])demo.launch()

Héberger votre application

Nous pouvons également utiliser HuggingFace Spaces pour héberger nos applications web et les partager facilement avec d’autres personnes.

Pour commencer à utiliser Spaces, vous devez posséder un compte. Suivez ce lien si vous n’êtes pas encore inscrit. Cela ne prendra pas plus de quelques minutes.

La prochaine étape consiste à créer un nouvel espace. Vous pouvez trouver des instructions plus détaillées dans la documentation.

Image by author

Pour le nouvel espace, vous devez remplir les paramètres suivants: nom, licence et Gradio comme votre kit de développement logiciel.

Image by author

Ensuite, vous devez engager votre code dans le référentiel Git depuis Hugging Spaces. Tout d’abord, nous devons cloner le référentiel.

-- cloner repogit clone https://huggingface.co/spaces/<votre_login>/<nom_de_votre_application>cd <nom_de_votre_application>

Récemment, HuggingFace a modifié le processus d’authentification Git, nous devons donc d’abord créer un jeton, puis le définir pour le référentiel Git.

git remote set-url origin https://<votre_login>:<token>@huggingface.co/spaces/<votre_login>/<nom_de_votre_application>git pull origin

Maintenant, il est temps d’engager les fichiers liés à notre application. Nous devons avoir au moins les fichiers suivants:

  • app.py avec le code Python qui lance l’application Gradio
  • requirements.txt avec la liste des packages Python dont vous avez besoin pour votre application. Dans notre cas, seulement pandas et plotly.

Ensuite, les étapes de base avec git: ajouter, valider et envoyer vers HuggingFaces.

git add app.pygit add requirements.txtgit commit -m 'Première version de l'application de simulateur de rétention'git push

Il a fallu quelques minutes pour construire l’application, et c’est fait. Maintenant, notre application web est opérationnelle sur HuggingFaces Spaces. Vous pouvez l’essayer ici.

Image par auteur

Cela semble beaucoup mieux que notre version initiale, car la mise en page ne nécessite pas de défilement, et les utilisateurs n’ont pas besoin de deviner ce que signifient les paramètres a, c et d.

Prédiction de la rétention

Nous avons appris comment générer des graphiques basés sur un ensemble de paramètres dans une application web. Mais dans la vie réelle, nous devons généralement entrer beaucoup de données, alors découvrons comment utiliser les données de fichiers .csv dans les applications.

A titre d’exemple, nous examinerons les données réelles de rétention pour les premières périodes et essayerons de prédire la rétention pour les périodes suivantes. C’est une tâche assez courante, car nous ne voulons généralement pas attendre trois mois pour comparer la rétention du troisième mois de la nouvelle cohorte. Nous téléchargerons les données factuelles sous forme de fichier .csv.

Ne perdons pas notre temps et passons à la mise en œuvre.

Obtention des données à partir des fichiers

Voici le code pour générer toute l’interface et la logique métier. Cela peut sembler un peu complexe. Ne vous inquiétez pas. Nous discuterons des points clés plus tard.

# analyse le fichier ou la chaîne de caractères et renvoie un dataframe def parse_file(input_text_or_file, num_periods):    if isinstance(input_text_or_file, str):        df = pd.read_csv(StringIO(input_text_or_file), sep = '\t')    else:        df = pd.read_csv(input_text_or_file.name, sep = '\t')    return df# prend un dataframe et renvoie un graphique def show_graph_for_df(df, num_periods):    df['period'] = df.period.map(int)    df['retention_fact'] = df.retention_fact.map(float)    result = scipy.optimize.minimize(lambda x: get_mse_for_retention(x, df), [random.random(), random.random(), random.random()])    a, c, d = result.x    pred_df = pd.DataFrame({'period': range(num_periods + 1)})    pred_df['retention_pred'] = pred_df.period.map(lambda x: get_retention_same_event(a, c, d, x))    pred_df = pred_df.merge(df, how = 'left')        fig = go.Figure()    fig.add_trace(go.Scatter(x=pred_df.period, y=pred_df.retention_fact, name='fait',                             line=dict(color=plotly.colors.qualitative.Prism[0], width=3)))        fig.add_trace(go.Scatter(x=pred_df.period, y=pred_df.retention_pred, name='prédiction',                             line=dict(color=plotly.colors.qualitative.Prism[0], width=3, dash='dot')))        fig.update_layout(title='Modèle de rétention quotidienne (a = %.2f, c = %.2f, d = %.2f)' % (a, c, d),                       yaxis_title='rétention',                       xaxis_title='période')    return fig# prend un fichier et renvoie un graphique def show_graph_for_file(temp_file, num_periods):    df = parse_file(temp_file, num_periods)    return show_graph_for_df(df, num_periods)# exemple codé en dur des données default_csv = 'period\tretention_fact\n0\t1\n1\t0.55\n2\t0.4\n3\t0.35\n4\t0.3\n'# interface with gr.Blocks() as demo:    gr.Markdown('# Prédiction de la courbe de rétention 📊')    periods = gr.Dropdown([10, 30, 90, 180], label="Nombre de périodes", value = 30)    gr.Markdown('Téléchargez un fichier .csv avec des données, utilisez les données par défaut comme exemple ou entrez les chiffres manuellement dans la section Données téléchargées.')    gr.Markdown('''__Format de fichier:__ 2 colonnes (`période` et `retention_fact`''')        with gr.Row():        upload_button = gr.UploadButton(label="Télécharger le fichier", file_types = ['.csv'], live=True, file_count = "single")        default_button = gr.Button('Montrer un exemple')        with gr.Row():        with gr.Accordion("Données téléchargées", open=False):            gr.Markdown('Vous pouvez modifier les valeurs dans le tableau')            table = gr.Dataframe(type="pandas", col_count=2, interactive = True, headers = ['période', 'retention_fact'])                with gr.Row():            image = gr.Plot()        # logique métier des déclencheurs et des événements    upload_button.upload(fn=show_graph_for_file, inputs=[upload_button, periods], outputs=image, api_name="upload_graph")    upload_button.upload(fn=parse_file, inputs=[upload_button, periods], outputs=table, api_name="upload_csv")    default_button.click(fn=lambda x: show_graph_for_file(default_csv, x), inputs=[periods], outputs=image, api_name="upload_example_graph")    default_button.click(fn=lambda x: parse_file(default_csv, x), inputs=[periods], outputs=table, api_name="upload_example_csv")    table.change(fn=show_graph_for_df, inputs=[table, periods], outputs=image, api_name="upload_table_graph")    periods.change(fn=show_graph_for_df, inputs=[table, periods], outputs=image, api_name="upload_periods_graph")demo.launch(debug=True)

Regardons de plus près les éléments suivants dans l’interface :

  • periodes – paramètre d’entrée,
  • bouton_chargement – paramètre d’entrée qui permet de charger des données à partir d’un fichier .csv,
  • bouton_par_defaut – permet de mettre à jour le tableau et le graphique avec des valeurs prédéfinies à titre d’exemple,
  • tableau montre le cadre de données à partir des données chargées (soit à partir d’un fichier .csv, soit à partir d’un exemple); vous pouvez également modifier les chiffres dans le tableau en place, et le graphique sera mis à jour – donc c’est également un paramètre d’entrée,
  • image – paramètre de sortie, qui montre un graphique.
Image de l'auteur

La fonction parse_file obtient soit un fichier à partir du bouton_chargement, soit une chaîne à partir de l’exemple par défaut et renvoie un cadre de données pandas que nous pourrions utiliser par la suite. Ainsi, l’utilisation de données à partir de fichiers est assez simple.

La logique métier cruciale est définie dans l’extrait de code ci-dessous. Il définit les actions pour tous les éléments de l’interface :

  • pour charger un fichier .csv – le tableau et le graphique sont mis à jour,
  • pour cliquer sur le bouton “Afficher l’exemple” – le tableau et le graphique sont mis à jour,
  • pour modifier les données dans le tableau – seul le graphique est mis à jour,
  • pour modifier le nombre de périodes – seul le graphique est mis à jour.
bouton_chargement.upload(fn=afficher_graphique_pour_fichier, inputs=[bouton_chargement, periodes], outputs=image, api_name="telecharger_graphique")bouton_chargement.upload(fn=parse_file, inputs=[bouton_chargement, periodes], outputs=tableau, api_name="telecharger_csv")bouton_par_defaut.click(fn=lambda x: afficher_graphique_pour_fichier(csv_par_defaut, x), inputs=[periodes], outputs=image, api_name="telecharger_graphique_exemple")bouton_par_defaut.click(fn=lambda x: parse_file(csv_par_defaut, x), inputs=[periodes], outputs=tableau, api_name="telecharger_csv_exemple")tableau.change(fn=afficher_graphique_pour_df, inputs=[tableau, periodes], outputs=image, api_name="telecharger_graphique_tableau")periodes.change(fn=afficher_graphique_pour_df, inputs=[tableau, periodes], outputs=image, api_name="telecharger_graphique_periodes")

Définition de la fonction de meilleur ajustement

La partie essentielle de notre solution est de trouver la fonction de meilleur ajustement pour nos données factuelles. Voyons comment le faire.

  • Tout d’abord, nous définissons la fonction get_mse_for_retention qui renvoie l’erreur pour l’ensemble des paramètres (a, c et d). Elle prend également le cadre de données en entrée.
  • Nous utilisons l’erreur quadratique moyenne (MSE) standard comme erreur que nous minimiserons.
  • Ensuite, nous utiliserons la fonction scipy.optimize.minimize pour l’optimisation. Nous devons passer seulement deux paramètres : la fonction à optimiser (nous avons passé la fonction lambda avec un cadre de données intégré puisque nous optimisons uniquement les paramètres) et les valeurs initiales des paramètres (juste une liste de valeurs aléatoires).
  • Après l’optimisation, nous pouvons accéder aux paramètres optimaux en utilisant result.x.
def get_mse_for_retention(params, df):    tmp_df = df.copy()    tmp_df['retention_pred'] = tmp_df.index.map(        lambda x: get_retention_same_event(params[0], params[1], params[2], x)    )        tmp_df['se'] = (tmp_df.retention_fact - tmp_df.retention_pred)    tmp_df['se'] = tmp_df['se']**2        return tmp_df.se.mean() ** 0.5result = scipy.optimize.minimize(lambda x: get_mse_for_retention(x, df), [random.random(), random.random(), random.random()])a, c, d = result.xprint(a, c, d)

C’est tout, maintenant nous connaissons la courbe de rétention théorique pour nos données factuelles et pouvons l’utiliser dans notre application pour la prédiction.

Dernière étape

J’ai suivi les mêmes instructions et j’ai également publié cette application dans HuggingFace Spaces. Vous pouvez donc essayer de jouer avec ici.

Vous pouvez trouver le code complet des deux applications dans GitHub.

Résumé

Dans cet article, nous avons abordé les bases de la bibliothèque Gradio et appris comment construire d’agréables applications web en utilisant uniquement Python.

Nous avons appris quelques approches :

  • La classe de haut niveau gr.Interface qui vous permet d’obtenir rapidement un prototype fonctionnel,
  • Une approche plus personnalisable en utilisant gr.Blocks où vous pouvez spécifier la mise en page exacte dont vous avez besoin et définir des relations complexes entre les entrées et les sorties.

Je vous remercie beaucoup d’avoir lu cet article. J’espère qu’il vous a été instructif. Si vous avez des questions ou des commentaires supplémentaires, veuillez les laisser dans la section des commentaires.

Référence

Cet article s’inspire du cours “Building Generative AI Applications with Gradio” disponible sur course.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

AI

Surgeler les couches d'un modèle d'apprentissage profond - la bonne façon

Il est souvent utile de figer certains des paramètres, par exemple lorsque vous affinez votre modèle et que vous souh...

Apprentissage automatique

TaatikNet Apprentissage de séquence à séquence pour la translittération de l'hébreu

Cet article décrit TaatikNet et comment implémenter facilement des modèles seq2seq. Pour le code et la documentation,...

Actualités sur l'IA

Robots de livraison de nourriture Uber Eats prêts à être utilisés dans plusieurs villes américaines.

La société de robots de service Serve Robotics a déclaré qu'Uber Eats déploiera jusqu'à 2 000 de ses robots de livrai...

Apprentissage automatique

Repousser les limites dans la conception de protéines avec un nouveau modèle d'IA qui comprend les interactions avec n'importe quel type de molécule.

Après la révolution initiée par AlphaFold de DeepMind en biologie structurale, le domaine étroitement lié de la conce...