<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[OSS by MAIF - Medium]]></title>
        <description><![CDATA[Designing and building commons since 1934 - Medium]]></description>
        <link>https://medium.com/oss-by-maif?source=rss----75e417c6fe68---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>OSS by MAIF - Medium</title>
            <link>https://medium.com/oss-by-maif?source=rss----75e417c6fe68---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:30:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/oss-by-maif" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Meteole fête sa première année en open source]]></title>
            <link>https://medium.com/oss-by-maif/meteole-f%C3%AAte-sa-premi%C3%A8re-ann%C3%A9e-en-open-source-e3907f068c17?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/e3907f068c17</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[climat]]></category>
            <category><![CDATA[meteo]]></category>
            <category><![CDATA[data]]></category>
            <dc:creator><![CDATA[Thomas Bouche]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 13:18:56 GMT</pubDate>
            <atom:updated>2026-03-05T13:18:54.975Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*KI_HVoTNxs_BUNCiRS9x9w.jpeg" /></figure><p>En janvier 2025, nous avons ouvert le code de <a href="https://github.com/MAIF/meteole">Meteole</a>, une bibliothèque Python destinée à simplifier l’accès aux données de Météo‑France. Un an plus tard, le bilan est encourageant : plusieurs contributeurs externes ont apporté des correctifs, des améliorations et de nouveaux cas d’usage qui n’auraient pas émergé en interne — confirmant tout l’intérêt de l’open source pour un package simple dédié à l’accès aux données de Météo-France.</p><p>Cette dynamique a enrichi <a href="https://github.com/MAIF/meteole">Meteole</a> de nouveaux modèles et de nouveaux usages. La prochaine grande étape concernera l’accès facilité aux <strong>données d’observation</strong> des stations. Si ce sujet vous intéresse ou si vous avez des idées de fonctionnalités, nous serons ravis d’échanger avec vous. Vous pouvez ouvrir une issue ou contribuer directement.</p><p>Pour une présentation plus détaillée de la démarche et des fonctionnalités de Meteole, vous pouvez consulter cet <a href="https://medium.com/oss-by-maif/meteole-simplifier-lacc%C3%A8s-aux-donn%C3%A9es-m%C3%A9t%C3%A9o-afeec5e5d395">article</a>.</p><h3>Fonctionnalités ajoutées cette année</h3><p>Grâce aux retours et aux contributions de la communauté, plusieurs avancées ont été intégrées.</p><p><strong>✔ Nouveaux modèles intégrés</strong></p><p>Des contributeurs ont enrichi Meteole avec de nouveaux modèles météo :</p><ul><li><strong>PIAF </strong>(Prévision Immédiate Agrégée Fusionnée), pour des prévisions de précipitations toutes les 5 minutes à haute résolution et très courte échéance (J-4 à T+3H).</li><li><strong>PE‑AROME</strong> et <strong>PE‑ARPEGE</strong>, permettant d’accéder aux prévisions d’un ensemble de simulations.</li></ul><pre>from meteole import PiafForecast, AromePEForecast, ArpegePEForecast</pre><p><strong>✔ Ajout de l’accès aux prévisions à partir d’un point</strong></p><p>La première version de Meteole permettait d’interroger une zone en fournissant une emprise géographique (latitudes/longitudes).</p><p>Il est désormais possible de récupérer directement la prévision pour un <strong>point unique</strong> : Meteole sélectionne automatiquement le point de grille le plus proche.</p><pre>df_arome = arome_client.get_coverage(<br>    indicator=&quot;V_COMPONENT_OF_WIND_GUST__SPECIFIC_HEIGHT_LEVEL_ABOVE_GROUND&quot;,<br>    long = 2.35,<br>    lat = 48.85,<br>    )</pre><p><strong>✔ Compatibilité Python 3.12 et 3.13</strong></p><p>Le package est désormais compatible avec les versions de Python <strong>3.12</strong> et <strong>3.13</strong>, initialement limitées par une dépendance.</p><h3>Accès aux observations</h3><p>La version <strong>0.2.6</strong> de Meteole introduit un premier accès aux <strong>données d’observation</strong>, en permettant la récupération des mesures issues d’une station individuelle.</p><p>Meteole utilise l’<a href="https://confluence-meteofrance.atlassian.net/wiki/spaces/OpenDataMeteoFrance/pages/854261785/API+Donn+es+Climatologiques"><strong>API Données Climatologiques</strong></a>, qui fournit la liste des stations et fonctionne en mode <strong>asynchrone</strong>, avec une logique de « commande » puis de « récupération du fichier » une fois que Météo‑France a préparé les données.</p><h3>1. Récupération des stations</h3><p>L’identification des stations disponibles dépend de deux paramètres :</p><ul><li>la <strong>fréquence</strong> des données souhaitée (6 minutes, horaire, quotidienne),</li><li>le <strong>département</strong> dans lequel rechercher les stations.</li></ul><p>La méthode get_stations de Meteole enrichit cette logique avec plusieurs options destinées à simplifier la recherche de la station la plus pertinente :</p><ul><li><strong>Tri par distance</strong> si lat/lon sont renseignées : Meteole réordonne localement la liste des stations selon leur proximité du point fourni.</li><li><strong>Ajout des départements voisins</strong> : utile lorsque la station la plus proche se situe juste en dehors du département demandé.</li><li><strong>Filtrage des stations ouvertes </strong>: permet d’exclure les stations fermées.</li></ul><pre>from meteole import DPClim<br><br>client = DPClim(application_id=APP_ID, frequency=&quot;daily&quot;)<br><br>stations = client.get_stations(<br>    departement = 1,<br>    lat=46.204,  # if lat, lon are given, stations are sorted by distance<br>    lon=5.218,<br>    add_neighbours=False,  # add neighbouring departements, default True<br>    open_only=False,<br>)</pre><h3>2. Récupération des observations</h3><p>L’API Données Climatologiques impose un déroulement en <strong>deux étapes</strong> :</p><ul><li>Passage d’une commande indiquant la station et la période demandée</li><li>Téléchargement du fichier associé lorsque sa préparation est terminée</li></ul><p>Meteole simplifie ce processus en combinant les deux étapes via la méthode fetch_data.</p><pre>data = client.fetch_data(<br>  station_id = station_id,<br>  start = &quot;2026-01-01T00:00:00Z&quot;, <br>  end = &quot;2026-01-05T00:00:00Z&quot;,<br>  wait_for_file = 5 #number of seconds to wait before retrieving the file after ordering it<br>  )</pre><p>Pour plus de détails sur comment récupérer les données d’observation associées à une station, vous pouvez consulter ce <a href="https://github.com/MAIF/meteole/blob/main/tutorial/Get_observations.ipynb">tutoriel</a>.</p><h3>Prochaines étapes</h3><p>Afin d’étendre l’accès aux observations, une évolution importante consiste à faciliter la sélection et la récupération des données d’un ensemble de stations (filtres géographiques, disponibilité des indicateurs, période d’activité…). La parallélisation des commandes sera notamment indispensable, chaque station nécessitant une requête indépendante.</p><p>Si vous êtes intéressé par des fonctionnalités facilitant l’accès à ces données, n’hésitez pas à ouvrir une <a href="https://github.com/MAIF/meteole/issues">issue </a>— ou mieux encore, à contribuer directement.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3907f068c17" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/meteole-f%C3%AAte-sa-premi%C3%A8re-ann%C3%A9e-en-open-source-e3907f068c17">Meteole fête sa première année en open source</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meteole : Simplifier l’accès aux données météo]]></title>
            <link>https://medium.com/oss-by-maif/meteole-simplifier-lacc%C3%A8s-aux-donn%C3%A9es-m%C3%A9t%C3%A9o-afeec5e5d395?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/afeec5e5d395</guid>
            <category><![CDATA[climate-models]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[meteorology]]></category>
            <category><![CDATA[data]]></category>
            <dc:creator><![CDATA[Thomas Bouche]]></dc:creator>
            <pubDate>Tue, 21 Jan 2025 10:12:54 GMT</pubDate>
            <atom:updated>2025-01-21T10:12:54.334Z</atom:updated>
            <content:encoded><![CDATA[<h3>Meteole : Simplifier l’accès aux données météo</h3><p>La MAIF, dans une démarche de responsabilité et de prévention face aux enjeux climatiques, a mis en place une “Cellule climat” dédiée à l’étude et à la modélisation des risques climatiques. Une des missions de cette cellule est d’anticiper les impacts d’évènements climatiques sur ses sociétaires et de mieux gérer les situations d’urgence. Par exemple, elle aide à prévoir les pics de charges sur les réseaux des gestionnaires en cas de tempête ou d’inondation, assurant ainsi leur disponibilité et leur réactivité face aux sinistres. Pour ces analyses, les modélisateurs s’appuient sur les <strong>données de prévisions</strong> fournies par <strong>Météo-France</strong>.</p><p>Météo-France propose deux modèles de prévisions météorologiques majeurs accessibles via ses API : <strong>AROME</strong> et <strong>ARPEGE</strong>.</p><ul><li><strong>AROME</strong> est un modèle à haute résolution (1,3 km) mis à jour toutes les 3 heures, offrant des prévisions jusqu’à 51 heures.</li><li><strong>ARPEGE </strong>est un modèle global avec une résolution de 10 km, mis à jour toutes les 6 heures et capable de fournir des prévisions jusqu’à 114 heures.</li></ul><p>Météo-France met à disposition ses données météo via des <a href="https://portail-api.meteofrance.fr/web/fr/">API publiques</a>. Pour exploiter ces modèles dans la modélisation des risques climatiques, la MAIF a développé un <strong>package Python</strong> interne. Ce package simplifie l’accès aux prévisions pour tous ses utilisateurs. En parallèle, nous avons choisi de rendre cet outil accessible à tous en publiant <a href="https://github.com/MAIF/meteole"><strong>Meteole</strong></a> en open source, offrant ainsi ses fonctionnalités à la communauté.</p><figure><img alt="Logo Meteole par Maif" src="https://cdn-images-1.medium.com/max/900/0*k8CSGJmG0jbxzUS9.png" /></figure><h3>A qui s’adresse Meteole ?</h3><blockquote>Conçu pour faciliter l’accès aux données météorologiques, <strong>Meteole</strong> permet de se concentrer sur l’essentiel : la modélisation et l’analyse.</blockquote><p>Que vous soyez <strong>développeur Python</strong>, <strong>data scientist</strong> travaillant sur des données météorologiques, ou <strong>spécialiste de la modélisation des périls climatiques</strong>, Meteole est conçu pour vous. Mais pas seulement : même un <strong>utilisateur curieux</strong> souhaitant automatiser la récupération de données météo pourra trouver son compte avec cet outil.</p><h4>Avec Meteole, les prévisions météo deviennent accessibles en quelques lignes de code en :</h4><ul><li>aidant au paramétrage de la récupération des indicateurs Météo ;</li><li>standardisant l’utilisation des prévisions AROME et ARPEGE ;</li><li>automatisant la gestion des tokens pour un accès simplifié à l’API Meteo-France ;</li><li>facilitant l’intégration des prévisions dans une pipeline de modélisation.</li></ul><blockquote>Exemple d’utilisation de Meteole pour récupérer un indicateur de pression atmosphérique en quelques lignes de code</blockquote><pre>from meteole import ArpegeForecast<br><br>arpege_client = ArpegeForecast(application_id=APPLICATION_ID)<br><br>df_forecast = arpege_client.get_coverage(<br>    indicator=&quot;PRESSURE_GROUND_OR_WATER_SURFACE&quot;,<br>    heights=None,                <br>    pressures=None,             <br>    forecast_horizons=[1, 2],   <br>    run=&quot;2025–01–10T00.00.00Z&quot;,          <br>    interval=None,<br>    long = (-5.1413, 9.5602),<br>    lat = (41.33356, 51.0889),         <br>    coverage_id=None,<br>    )</pre><blockquote>Pour récupérer des prévisions pour plusieurs indicateurs à la fois, utilisez la méthode <em>get_combined_coverage</em>. Consultez ce <a href="https://github.com/MAIF/meteole/blob/main/tutorial/Fetch_forecast_for_multiple_indicators.ipynb">tutoriel</a> pour plus de détails.</blockquote><h3>Plus de détails sur ce que propose Meteole</h3><h4>1. Aide au paramétrage de la récupération des Indicateurs Météo</h4><p>Les prévisions météo des API de Météo-France reposent sur des <strong>paramètres clés</strong> (date, horizon de prévision, caractéristiques de l’indicateur…) qui varient selon les indicateurs, ce qui peut rendre leur utilisation complexe.</p><h4><strong>1.1 — Le </strong><strong>coverage_id</strong></h4><p>Le paramètre principal, le coverage_id, combine plusieurs informations importantes :</p><ul><li>indicator : le nom de l&#39;indicateur.</li><li>run : la date de prévision du modèle.</li><li>interval <em>(optionnel)</em> : la période de temps associée, par exemple &quot;P1D&quot; pour les précipitations sur 24 heures.</li></ul><p><strong>Exemples de </strong>coverage_id<strong> :</strong></p><ul><li>PRESSURE_GROUND_OR_WATER_SURFACE___2025–01–10T00.00.00Z</li><li>TOTAL_PRECIPITATION_GROUND_OR_WATER_SURFACE___2025-01-10T00.00.00Z_P1D</li></ul><p>Les indicateurs disponibles, ainsi que les run et les interval, peuvent être récupérés via la méthode get_capabilities().</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*iC3EyA9HQw2A7cXXnvc8Yg.png" /><figcaption>Exemple de résultats du get_capabilities()</figcaption></figure><h4><strong>1.2 — Heure et autres paramètres</strong></h4><p>En plus du coverage_id, il est nécessaire de spécifier l’heure de la prédiction souhaitée. Meteole facilite cette étape avec le paramètre forecast_horizons, qui permet de récupérer les données pour une liste d&#39;heures.</p><p>Pour certains indicateurs, des paramètres supplémentaires peuvent être nécessaires, comme :</p><ul><li>height : par exemple, la hauteur à laquelle la température est mesurée.</li><li>pressure : utilisé pour des indicateurs spécifiques.</li></ul><p>Ces informations complémentaires peuvent être obtenues grâce à la méthode get_coverage_description(coverage_id), qui détaille les configurations disponibles pour un indicateur donné.</p><p>Exemples de résultats du get_coverage_description :</p><pre>{&#39;forecast_horizons&#39;: [1,  2,  3,  4,  5,  6,  7,  8,  9,  10, ...],<br> &#39;heights&#39;: [10],<br> &#39;pressures&#39;: []}</pre><h4>1.3 — Couverture géographique</h4><p>La couverture géographique des données peut être précisée avec les paramètres lat et long. Par défaut, l’ensemble de la <strong>France métropolitaine</strong> est récupéré.</p><h4>1.4— Fonctionnalités pour simplifier l’utilisation</h4><ul><li><strong>Gestion des paramètres par défaut</strong> : si un paramètre n’est pas spécifié, une valeur par défaut est utilisée et enregistrée dans les logs.</li><li><strong>Vérification des entrées</strong> : si un paramètre invalide est fourni, un message d’erreur explicite est généré.</li><li><strong>Options de paramétrage</strong>: vous pouvez soit utiliser les paramètres individuels (indicator_name, run, et interval), soit fournir directement un coverage_id.</li></ul><h4>2. Utilisation harmonisée des modèles AROME et ARPEGE</h4><p>Meteole s’appuie sur une architecture basée sur des classes abstraites pour faciliter l’utilisation des prévisions AROME et ARPEGE. Cette approche permet d’uniformiser la syntaxe des méthodes et les formats des résultats, rendant les deux modèles accessibles de manière cohérente.</p><h4>3. Automatisation de la gestion des Tokens</h4><p>Le processus manuel de génération des tokens (clé d’authentification nécessaire pour accéder aux services d’une API en toute sécurité) depuis le portail des API Météo-France peut vite devenir chronophage. Meteole automatise la génération de ces tokens à partir de l’application_id.</p><p>⚠️ L’utilisation de l’API Météo-France nécessite la création d’un compte sur le portail API de Météo-France : pour créer votre compte ou en savoir plus, consultez cette <a href="https://portail-api.meteofrance.fr/web/fr/faq">FAQ</a>.</p><h4><strong>4. Intégration facile des prévisions dans une pipeline de modélisation</strong></h4><p>Les prévisions obtenues via Meteole sont directement fournies sous forme de pandas.DataFrame, un format standard et pratique pour une intégration dans vos pipelines de modélisation.</p><h3>Meteole permet(tra) aussi d’exploiter d’autres données météo</h3><h4>Le bulletin de vigilance</h4><p>Meteole permet également de récupérer les données de <strong>bulletin de vigilance</strong>. Ces informations sont utiles pour déclencher des modélisations uniquement lorsque le niveau de vigilance météo l’exige. Cela permet d’être plus frugale dans la récupération des données de prévisions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/204/1*gHs5JoUzYl7OEk2OjNkOcw.png" /><figcaption>Vignette de vigilance</figcaption></figure><pre>from meteole import Vigilance<br>client = Vigilance(application_id=APPLICATION_ID)<br>df_phenomenon, df_timelaps = client.get_phenomenon()</pre><h4>Les données d’observation</h4><p>Actuellement, Meteole ne permet pas de récupérer directement les données d’observations des stations météorologiques de Météo-France. Ces données ne sont pas utilisées au sein de la MAIF, sauf à des fins exploratoires. Vous souhaitez contribuer à l’implémentation de cette fonctionnalité ? Dîtes-le nous directement sur <a href="https://github.com/MAIF/meteole/issues/21">Github</a>.</p><h3>Conclusion</h3><p>Meteole est en<strong> open source</strong>, il est disponible sur <a href="https://github.com/MAIF/meteole"><strong>github</strong></a>. Pour commencer à utiliser Meteole, consultez la <a href="https://maif.github.io/meteole/home/"><strong>documentation officielle</strong></a>. Des <a href="https://github.com/MAIF/meteole/tree/main/tutorial"><strong>tutoriels</strong></a> sont également disponibles pour vous accompagner dans la prise en main de l’outil.</p><h3>Notre Engagement Open Source</h3><p>Meteole s’inscrit dans une démarche globale de solutions open source développées par la MAIF, dans les domaines de la <strong>data</strong> et de l’<strong>intelligence artificielle</strong> :</p><ul><li><a href="https://github.com/MAIF/melusine"><strong>Melusine</strong></a> : pour le traitement des emails, facilitant l’analyse et la classification des messages.</li><li><a href="https://github.com/MAIF/shapash"><strong>Shapash</strong></a> : pour rendre le machine learning interprétable et compréhensible par tous.</li><li><a href="https://github.com/MAIF/eurybia"><strong>Eurybia</strong></a> : pour assurer la qualité des modèles de machine learning en production, en détectant la dérive des données.</li><li><a href="https://github.com/MAIF/arta"><strong>Arta</strong></a> : pour simplifier la gestion des règles en Python.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=afeec5e5d395" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/meteole-simplifier-lacc%C3%A8s-aux-donn%C3%A9es-m%C3%A9t%C3%A9o-afeec5e5d395">Meteole : Simplifier l’accès aux données météo</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enhancing Shapash Contribution Plots with Jittering, Smart Selection, and Volume Representation]]></title>
            <link>https://medium.com/oss-by-maif/enhancing-shapash-contribution-plots-with-jittering-smart-selection-and-volume-representation-27ebfebaadaf?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/27ebfebaadaf</guid>
            <category><![CDATA[explainable-ai]]></category>
            <category><![CDATA[shapash]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[plotly]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Guillaume Vignal]]></dc:creator>
            <pubDate>Mon, 15 Jul 2024 12:42:19 GMT</pubDate>
            <atom:updated>2024-07-15T12:46:02.677Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://github.com/MAIF/shapash"><strong>Shapash</strong></a> is a cutting-edge library for <strong>machine learning interpretability</strong>, offering diverse tools to facilitate understanding of model predictions. Three significant improvements in Shapash’s <strong>contribution plots</strong> include <strong>jittering points</strong> on violin plots, <strong>smart selection</strong> for diverse class representation, and <strong>volume representation</strong> via curves and bars. These enhancements greatly enhance the <strong>clarity</strong> and <strong>interpretability</strong> of the plots, enabling users to derive deeper <strong>insights</strong> from their data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*3Kve97IjvPVrXqWwZw_WCw.gif" /></figure><h3>1. Jittering Points on Violin Plot</h3><p><strong>Violin plots</strong> in Shapash display detailed distributions of <strong>feature contributions</strong>. However, overlapping points can obscure individual values. <strong>Jittering</strong> introduces controlled random noise to disperse points along the x-axis, preventing overlap and ensuring clearer visibility.</p><p>Here’s the key snippet illustrating jittering:</p><pre># Binning data into intervals and calculating the percentage of points in each interval<br>intervals = pd.cut(data, bins, duplicates=&quot;drop&quot;)<br>points_per_interval = intervals.value_counts()<br>total_points = len(data)<br>percentage_per_interval = (points_per_interval / total_points).sort_index().to_dict()<br><br># Mapping those percentages to the original data points<br>percentage_series = intervals.map(percentage_per_interval).to_numpy()<br># Creating jittered points<br>jitter = np.random.normal(mean, std, len(percentage_series))<br>if np.isnan(percentage_series).any():<br>    percentage_series.fill(1)<br>if side in [&quot;negative&quot;, &quot;positive&quot;]:<br>    jitter = np.abs(jitter)<br>jitter = np.clip(jitter, clip_min, clip_max)<br>if side == &quot;negative&quot;:<br>    jitter *= -1<br>jittered_points = numerical_features + np.clip(jitter * percentage_series, -0.5, 0.5)</pre><h4>How It Works</h4><ol><li><strong>Binning Data and Calculating Percentages</strong>:<br>The data is segmented into intervals, and the percentage of points in each interval is computed.</li><li><strong>Mapping Percentages to Data Points</strong>:<br>The calculated percentages are mapped back to the original data points, creating percentage_series.</li><li><strong>Generating Jitter</strong>:<br>Random noise (jitter) is added to the data points to disperse them and avoid overlap.</li><li><strong>Handling Class Distinctions</strong>:<br>Depending on whether the side is <strong>“negative”</strong> or <strong>“positive”</strong>, adjustments ensure clear separation between classes.</li></ol><h4>Summary</h4><p>Jittering enhances the clarity of violin plots by dispersing points and making individual contributions more distinguishable. In classification tasks, it helps differentiate predictions for <strong>class 0</strong> (left side, negative values) and <strong>class 1</strong> (right side, positive values).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IT55KmSqSy7nQQ7PilXPUQ.png" /></figure><h4>Value Derived from Jittering</h4><ul><li><strong>Enhanced Visibility</strong>: Points are clearly separated, improving interpretability.</li><li><strong>Clear Class Differentiation</strong>: Facilitates understanding of class-specific contributions.</li><li><strong>Visual Appeal</strong>: Reduces clutter, enhancing aesthetic appeal of the plot.</li></ul><h3>2. Smart Sampling for Diverse Class Representation</h3><p>Shapash utilizes a <strong>smart sampling strategy</strong> to ensure a balanced representation of classes within the dataset. This approach involves clustering data points and sampling from each cluster, thereby avoiding biases towards specific classes and ensuring the selected points reflect the overall data distribution.</p><p>Here’s the function handling smart selection:</p><pre>def _intelligent_sampling(self, data, max_points, col_value_count, random_seed):<br>    &quot;&quot;&quot;<br>    Performs intelligent sampling based on the distribution of values in the specified column.<br>    &quot;&quot;&quot;<br>    rng = np.random.default_rng(seed=random_seed)<br><br>    # Check if data is numerical data<br>    is_col_str = True<br>    if data.dtype.kind in &quot;fc&quot;:<br>        is_col_str = False<br>    if (col_value_count &lt; len(data) / 20) or is_col_str:<br>        cluster_labels = data<br>        cluster_counts = cluster_labels.value_counts()<br>    else:<br>        n_clusters = min(100, len(data) // 20)<br>        kmeans = KMeans(n_clusters=n_clusters, random_state=random_seed, n_init=&quot;auto&quot;)<br>        cluster_labels = pd.Series(kmeans.fit_predict(data.values.reshape(-1, 1)))<br>        cluster_counts = cluster_labels.value_counts()<br><br>    weights = cluster_counts.apply(lambda x: (x ** 0.5) / x).to_dict()<br>    selection_weights = cluster_labels.apply(lambda x: weights[x])<br>    selection_weights /= selection_weights.sum()<br>    selected_indices = rng.choice(<br>        data.index.tolist(), max_points, p=selection_weights, replace=False<br>    )<br>    return selected_indices</pre><h4>How It Works</h4><p>The _intelligent_sampling function selects a subset of data based on the distribution of values in a specified column. Here’s how it operates:</p><ol><li><strong>Data Type Handling</strong>:<br>It checks if the data contains numerical (float or int) or categorical (object or category) data.</li><li><strong>Condition Check</strong>:<br>If the number of unique values (col_value_count) is less than 5% of the total rows in the dataset (len(data) / 20) or if the column contains string data, it uses the original column values without clustering (is_col_str).</li><li><strong>Clustering Approach</strong>:<br><strong>Numeric Data</strong>: For numeric columns with more than 5% unique values, the function performs KMeans clustering. It determines the number of clusters (n_clusters) based on either 100 clusters or a fraction of the dataset size (len(data[col]) // 20).<br><strong>Categorical Data</strong>: No clustering is applied to categorical data; it directly uses the original values.</li><li><strong>Cluster Weight Calculation</strong>:<br>If clustering is applied, weights for each cluster are calculated based on the square root of cluster counts ((x ** 0.5) / x). This ensures a balanced representation of clusters in the sampling process.</li><li><strong>Selection Process</strong>:<br>The function normalizes the calculated weights (selection_weights) so that they sum to 1, ensuring proportional selection probabilities.</li><li><strong>Random Selection</strong>:<br>Using a random number generator (rng.choice), the function selects max_points indices from the dataset based on the normalized weights (selection_weights). This strategy ensures the selected subset reflects the original data’s distribution.</li></ol><h3>Summary</h3><p>This approach ensures that the selected sample for plotting features represents the dataset’s diversity, enhancing the reliability and interpretability of Shapash’s visualizations.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ik8KUBsZg77AbUWWk7Y_sg.png" /></figure><h4>Value Derived from Smart Selection</h4><ul><li><strong>Balanced Class Representation</strong>: Prevents dominance of any single class in visualizations.</li><li><strong>Robust Interpretations</strong>: Ensures insights drawn are representative of overall data trends.</li><li><strong>Scalable Sampling</strong>: Efficiently handles large datasets while maintaining sampling integrity.</li></ul><h3>3. Volume Representation via Curves and Bars</h3><p>Shapash represents the <strong>volume of data points</strong> using <strong>curves for continuous variables</strong> and <strong>bars for discrete variables</strong>. This dual approach provides an <strong>accurate visual summary</strong> of how features are distributed across their range and how they contribute to the model’s predictions.</p><p>Here’s the code snippet illustrating volume representation:</p><pre>if feature_values.iloc[:, 0].dtype.kind in &quot;biufc&quot;:<br>    from sklearn.neighbors import KernelDensity<br><br>    # Using Kernel Density Estimation for continuous variables<br>    kde = KernelDensity(<br>        bandwidth=(max(feature_values_array) - min(feature_values_array)) / 100,<br>        kernel=&quot;epanechnikov&quot;,<br>    ).fit(feature_values_array[:, None])<br>    xs = np.linspace(min(feature_values_array), max(feature_values_array), 1000)<br>    log_dens = kde.score_samples(xs[:, None])<br>    y_upper = np.exp(log_dens) * h / (np.max(np.exp(log_dens)) * 3) + contributions_min<br>    y_lower = np.full_like(y_upper, contributions_min)<br>else:<br>    # Counting values for discrete variables<br>    feature_values_counts = feature_values.value_counts()<br>    xs = feature_values_counts.index.get_level_values(0).sort_values()<br>    y_upper = (<br>        feature_values_counts.loc[xs] / feature_values_counts.sum()<br>    ).values.flatten() / 3 + contributions_min<br>    y_lower = np.full_like(y_upper, contributions_min)<br><br># Creating the plot with either curve or bars<br>density_plot = go.Scatter(<br>    x=np.concatenate([pd.Series(xs), pd.Series(xs)[::-1]]),<br>    y=pd.concat([pd.Series(y_upper), pd.Series(y_lower)[::-1]]),<br>    fill=&quot;toself&quot;,<br>    hoverinfo=&quot;none&quot;,<br>    showlegend=False,<br>    line={&quot;color&quot;: self._style_dict[&quot;contrib_distribution&quot;]},<br>)</pre><h4>How It Works</h4><ul><li><strong>Continuous Variables</strong>:<br>Uses <strong>Kernel Density Estimation (KDE)</strong> to create smooth curves representing data distributions. Bandwidth is dynamically adjusted based on feature range.</li><li><strong>Discrete Variables</strong>:<br>Constructs bars showing frequency distribution of discrete values, normalized to highlight relative proportions.</li></ul><h4>Summary</h4><p>This approach visually represents feature distributions comprehensively, aiding in understanding data volumes and their impacts on model predictions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m2l0bOz_gAXeZi6J3KFAfA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ik8KUBsZg77AbUWWk7Y_sg.png" /></figure><h4>Value Derived from Volume Representation</h4><ul><li><strong>Clear Data Distribution</strong>: Provides intuitive insights into feature distributions.</li><li><strong>Impact Analysis</strong>: Visualizes how features contribute to model predictions.</li><li><strong>Enhanced Clarity</strong>: Simplifies interpretation of complex data patterns.</li></ul><h3>Conclusion</h3><p>Enhancements in Shapash’s contribution plots — jittering points, smart selection for diverse class representation, and volume representation via curves and bars — significantly improve the interpretability and usability of visualizations. These advancements empower users to gain deeper insights into model behaviors, facilitating informed decision-making in machine learning applications. By enhancing visualization clarity and representativeness, Shapash continues to be an invaluable tool for data scientists and analysts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27ebfebaadaf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/enhancing-shapash-contribution-plots-with-jittering-smart-selection-and-volume-representation-27ebfebaadaf">Enhancing Shapash Contribution Plots with Jittering, Smart Selection, and Volume Representation</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Presenting Arta — An Open Source Rules Engine]]></title>
            <link>https://medium.com/oss-by-maif/presenting-arta-an-open-source-rules-engine-3930b6d737aa?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/3930b6d737aa</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[rule-engine]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Charles Szersnovicz]]></dc:creator>
            <pubDate>Thu, 20 Jun 2024 10:02:50 GMT</pubDate>
            <atom:updated>2024-08-28T08:44:35.890Z</atom:updated>
            <content:encoded><![CDATA[<h3>Presenting Arta — A Python Rules Engine</h3><p><em>Make Rule Handling Simple</em></p><p><strong>Arta </strong>is a new open source <em>rules engine</em> from <a href="https://maif.github.io/">#OSSbyMAIF</a>.</p><h3>What is it?</h3><p><a href="https://maif.github.io/arta/"><strong>Arta</strong></a><strong> </strong>is a python library (i.e., a python package) for developers and data scientists designed to simplify rules handling in python code.</p><p>By configuring sets of rules in one or more YAML files rather than if / else in the source code, rules will gain clarity, and maintaining them will be child’s play.</p><p>With transparent and readable rules, collaboration will be improved. No need to read some code to check the rules anymore.</p><figure><img alt="Logo of Arta, an open source rules engine" src="https://cdn-images-1.medium.com/max/312/1*NKrYB19qAp0gJv_WMLVOLQ.png" /></figure><h3>Origins</h3><p>The idea of a simple <em>rules engine</em> came at <a href="https://medium.com/u/c4c75085d85f">MAIF</a> during a code refactoring of our <a href="https://github.com/MAIF/melusine"><em>Melusine</em></a> implementation.</p><p><em>Melusine</em><strong> </strong>is a document processing library which can be powered by machine learning models. When working on its code refactoring, the development team had to deal with many hard coded business rules. It could be things like:</p><blockquote>“If my email is important and is not forwarded and without a thank you email, etc., set its priority to high.”</blockquote><p>And so on…</p><p>Maintaining rules in the code is error-prone, it can be hard to check them and sometimes even tricky to find them. When using a <em>rules engine</em>, all rules are defined in the same place and follow a standard definition (i.e., same schema). No more business rules in the code and easy reading also leads to less regression bugs.</p><p>At this point, the team was looking for the absolute python <em>rules engine</em> package but couldn’t find the perfect fit: <strong>Arta </strong>was born.</p><h3>Open Source</h3><p>Why share <strong>Arta </strong>publicly? The idea came out quite naturally, maybe because open source philosophy shares some of MAIF values (i.e., common sharing, transparency). And it seemed to be a fair return from a team who was using some public packages (e.g., LangChain, Pydantic, FastAPI, pandas, etc.).</p><p>Sharing <strong>Arta </strong>follows the wish that it will help others within their own python projects.</p><h3>A Simple Example</h3><p>How to use it? One of <strong>Arta</strong>’s major goals is “simplicity”, as much as customization will allow. There are 3 implementation steps:</p><p>1. First, the hardest part, understand all the business rules of the concerned python application. Then, define them in a YAML file following <strong>Arta </strong>rule’s schema. Doing so will require building the different “condition expressions” (i.e., Boolean expressions) and identifying the triggered “actions”.</p><p>2. Second, implement the action functions in a python module. These functions can do anything: returning a filled dictionary, calling an API, writing in a database, etc.</p><p>3. Lastly, in your application code, instantiate the RulesEngine<em> </em>class and call its instance method apply_rules()<em> </em>by passing it the input data.</p><p>Here is a very (and intentionally) simple example. Use <strong>Arta</strong> to set a <em>priority</em> level on emails based on their properties and the following rules:</p><ul><li><strong>High</strong>: email is important and not forwarded and not a thank you email.</li><li><strong>Medium</strong>: email is about contract or customer.</li><li><strong>Low</strong>: everything else.</li></ul><h4>Step 1</h4><p>After installing <strong>Arta </strong>in your python virtual environment (e.g., pip install -U arta), create the following YAML file (e.g., rules.yaml):</p><pre>---<br>rules:<br>  default_rule_set:<br>    priority:<br>      HIGH:<br>        simple_condition: input.important==True and input.forwarded==False and input.content_type!=&quot;thank_you&quot;<br>        action: set_priority<br>        action_parameters:<br>          code: 1<br>          label: high<br>      MEDIUM:<br>        simple_condition: input.content_type==&quot;contract&quot; or input.content_type==&quot;customer&quot; <br>        action: set_priority<br>        action_parameters:<br>          code: 2<br>          label: medium<br>      LOW:<br>        simple_condition: null<br>        action: set_priority<br>        action_parameters:<br>          code: 3<br>          label: low<br><br>actions_source_modules:<br>  - action</pre><h4>Step 2</h4><p>Create a new python module with the action function implementation (e.g., action.py):</p><pre>from typing import Any<br><br><br>def set_priority(code: bool, label: str, **kwargs: Any) -&gt; dict[str, Any]:<br>    &quot;&quot;&quot;Return a dictionary containing the priority information.&quot;&quot;&quot;<br>    return {&quot;code&quot;: code, &quot;label&quot;: label}</pre><h4>Step 3</h4><p>Create a main.py module and apply the rules on the data set using <strong>Arta</strong>’s <em>rules engine</em>:</p><pre>from typing import Any<br><br>from arta import RulesEngine<br><br><br>eng = RulesEngine(config_path=&quot;.&quot;)<br><br>data: dict[str, Any] = {<br>    &quot;id&quot;: 1,<br>    &quot;from&quot;: &quot;someone@test.fr&quot;,<br>    &quot;to&quot;: &quot;someone-else@test.eu&quot;,<br>    &quot;important&quot;: True,<br>    &quot;forwarded&quot;: True,<br>    &quot;content_type&quot;: &quot;contract&quot;,<br>    &quot;subject&quot;: &quot;New subscription&quot;,<br>    &quot;content&quot;: &quot;Lorem ipsum...&quot;,<br>}<br><br>result: dict[str, Any] = eng.apply_rules(input_data=data)<br><br>print(result)</pre><p>You are done! You have set and used your first <strong>Arta</strong>’s rules. Now print the result. You should get for this email:</p><pre>{&#39;priority&#39;: {&#39;code&#39;: 2, &#39;label&#39;: &#39;medium&#39;}}</pre><p><em>N.B: If complex conditions are needed (i.e., doing math, calling a function to check things, etc.), you should use the </em><a href="https://maif.github.io/arta/how_to/#standard-condition"><em>standard conditions</em></a><em> rather than simple conditions. Using standard conditions is the most powerful way of using </em><strong><em>Arta</em></strong><em>.</em></p><h3>Next</h3><p>The package core maintainers are currently from <a href="https://medium.com/u/c4c75085d85f">MAIF</a> and will keep an eye on <strong>Arta </strong>as it is already used by productive apps.</p><p>Some GitHub issues have been opened for tracking new feature ideas but feel free to create new ones (even more for bugs) and of course, <strong>Arta </strong>is open to contributions (cf. repo’s <a href="https://github.com/MAIF/arta/blob/main/CONTRIBUTING.md">contributing guidelines</a>).</p><p>During the end of the year, we planned to publish new articles about <strong>Arta</strong>. As an example, we were thinking about writing on how we combined <a href="https://maif.github.io/arta/"><strong>Arta</strong></a><strong> </strong>and <a href="https://github.com/MAIF/melusine"><em>Melusine</em></a><strong> </strong>but also on how to create convenient custom conditions in order to simplify condition handling<strong>.</strong></p><p>For more information<strong>:</strong></p><ul><li><a href="https://github.com/MAIF/arta">Source code</a></li><li><a href="https://maif.github.io/arta/home/">Documentation</a></li><li><a href="https://www.linkedin.com/company/arta-python/">LinkedIn</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3930b6d737aa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/presenting-arta-an-open-source-rules-engine-3930b6d737aa">Presenting Arta — An Open Source Rules Engine</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Une nouvelle release pour Izanami]]></title>
            <link>https://medium.com/oss-by-maif/une-nouvelle-release-pour-izanami-60be69b37fae?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/60be69b37fae</guid>
            <category><![CDATA[wasm]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[feature-flags]]></category>
            <category><![CDATA[feature-toggles]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Benjamin Cavy]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 13:29:07 GMT</pubDate>
            <atom:updated>2024-03-25T14:42:38.145Z</atom:updated>
            <content:encoded><![CDATA[<p>L’équipe #OSSByMAIF est fière de libérer la <a href="https://maif.github.io/izanami/">v2 d’Izanami</a>.</p><p>Izanami v2 est une réécriture complète de la version précédente, qui se concentre sur les feature flags.</p><p>La version anglaise de cet article est <a href="https://medium.com/oss-by-maif/announcing-izanami-v2-62c753b445be">disponible ici</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hbuYCdXHNtMYXUEhoPGCvA.png" /></figure><h3>Qu’est-ce que les feature flags ?</h3><p>Les features flags sont un pattern de développement qui permet de décorréler l’activation des nouvelles fonctionnalités de leurs livraisons.</p><p>Positionner une fonctionnalité derrière un flag permet de l’activer ou la désactiver à volonté, ou seulement à certaines conditions, et ce, <strong>sans avoir besoin de redéployer l’application</strong>.</p><p>Les features flags sont également un facilitateur dans l’adoption du <strong>trunk based development</strong>. Ce flow de développement évite aux équipes de devoir gérer les branches de fonctionnalité qui vivent longtemps et les merges cauchemardesques qui en découlent. Les nouvelles fonctionnalités peuvent en effet être développées sur la branche principale, en étant conditionnées par des flags adaptés.</p><h3>Flags locaux ou Izanami</h3><p>Les <strong>feature flags locaux</strong> sont l’implémentation la plus commune du pattern. Ils sont définis entièrement dans le code de l’application concernée, généralement via des if/else qui peuvent par exemple s’appuyer sur des variables d’environnement ou des librairies dédiées.</p><p>Les flags locaux sont un bon moyen d’introduire le principe des feature flags dans une base de code et sont une solution suffisante pour des besoins peu complexes. Izanami offre une alternative en permettant de <strong>centraliser les feature flags</strong>, ce qui apporte certains avantages :</p><ul><li>Les flags peuvent être <strong>partagés par plusieurs applications</strong>, quelles que soient leurs technologies</li><li>Les conditions d’activation des flags peuvent être <strong>modifiées sans impact</strong> sur les applications clientes</li><li>Tous <strong>les flags sont au même endroit</strong>, ce qui simplifie leur administration et leur suivi</li><li>L’activation / désactivation d’un flag a un <strong>effet immédiat</strong> sur tous les consommateurs.</li></ul><h3>Les fonctionnalités d’Izanami</h3><p>Comme nous l’avons vu, Izanami est une solution de feature flags centralisée. Elle permet de définir et d’exposer facilement des flags.</p><p>Les flags peuvent être de simples interrupteurs ON/OFF ou avoir des conditions d’activation plus complexes, basées sur l’utilisateur, la date ou encore un script personnalisé.</p><p>Izanami expose les flags via HTTP, permettant à n’importe quelle application de récupérer facilement leur état.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kxMXS-JUGxtW0g27RX2Q0g.png" /><figcaption>Izanami s’intègre facilement avec n’importe quel langage</figcaption></figure><p>Pour ne rien gâcher, Izanami est open source (sous license Apache 2), ce qui vous permet de proposer de nouvelles fonctionnalités ou de nous aider à les développer !</p><h3>Changements de la v2</h3><p>Cette nouvelle version d’Izanami se concentre sur les features flags. Elle introduit des <strong>fonctionnalités orientées entreprises</strong>, comme le multi-tenant, l’organisation des features par projet et tags mais aussi le support des environnements (et bien plus) via les contextes. Les feature flags sont également beaucoup plus flexibles, car ils peuvent maintenant avoir plusieurs conditions d’activation.</p><p>Cette nouvelle version réimplémente par ailleurs les feature flags basés sur des scripts, en utilisant des scripts compilés en WASM grâce à WASMO et Extism.</p><p>L’utilisation de WASM rend l’exécution des scripts <strong>complètement sandboxée</strong> et permet l’écriture de features en utilisant une grande variété de langages, comme Rust, Go ou encore JavaScript.</p><p>Même si la v2 est une réécriture complète, elle assure la compatibilité avec les clients existants, à l’exception de quelques cas très marginaux. Un nouveau client Java arrive également avec la v2, avec moins de dépendances et plus de flexibilité dans les requêtes, notamment en ce qui concerne la gestion des erreurs et la gestion du cache.</p><p>Un autre grand changement est le <strong>choix de Postgres comme base de données</strong>, ce qui permet l’utilisation de fonctionnalités spécifiques pour offrir de meilleures performances.</p><p>L’A/B testing est absent de la v2 pour le moment, mais nous prévoyons de le réintégrer bientôt.</p><p>Enfin, Izanami n’inclut plus de gestion de configuration distribuée, d’une part, car il existe de nombreuses solutions open source qui le font très bien (Spring cloud config, Consul, ZooKeeper…), d’autre part car ce n’était pas la fonctionnalité la plus utilisée de la v1.</p><h3>La suite</h3><p>Même si la v2 est prête à être déployée en production, quelques fonctionnalités importantes sont encore en cours de développement :</p><ul><li><strong>Audit logs</strong> : cette fonctionnalité permettra de consulter l’historique de modification et de consultation des flags. Cela pourra être utile pour comprendre comment un flag est arrivé dans un état donné, ou encore pour s’assurer qu’un flag ne soit plus consulté avant de le supprimer.</li><li><strong>Client JavaScript</strong> : nous prévoyons l’écriture d’un nouveau client JavaScript pour exploiter pleinement les capacités de cette nouvelle version.</li><li><strong>A/B testing</strong> : l’A/B testing n’est pas présent dans Izanami v2, mais nous prévoyons de le réintégrer dans une version améliorée, comme nous l’avons fait pour les feature flags.</li></ul><p>Pour en savoir plus, n’hésitez pas à consulter <a href="https://maif.github.io/izanami/">la documentation</a> ou le <a href="https://github.com/MAIF/izanami">repo Github du projet</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60be69b37fae" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/une-nouvelle-release-pour-izanami-60be69b37fae">Une nouvelle release pour Izanami</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Announcing Izanami v2]]></title>
            <link>https://medium.com/oss-by-maif/announcing-izanami-v2-62c753b445be?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/62c753b445be</guid>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[wasm]]></category>
            <category><![CDATA[feature-toogles]]></category>
            <category><![CDATA[feature-flags]]></category>
            <dc:creator><![CDATA[Benjamin Cavy]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 13:20:13 GMT</pubDate>
            <atom:updated>2024-03-25T14:43:08.933Z</atom:updated>
            <content:encoded><![CDATA[<p>#OSSByMAIF Team is proud to release <a href="https://maif.github.io/izanami/">Izanami v2</a>.</p><p>This version is a <strong>complete rewrite</strong> of Izanami, that focuses on feature flags.</p><p>French version of this article is <a href="https://medium.com/oss-by-maif/une-nouvelle-release-pour-izanami-60be69b37fae">available here</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hbuYCdXHNtMYXUEhoPGCvA.png" /></figure><h3>What is feature flag ?</h3><p>Feature flag is a development pattern that allows to decorrelate new features activation from their delivery.</p><p>Placing a feature behind a flag allows enabling or disabling it at will or only at some conditions, <strong>without needing to redeploy the application</strong>.</p><p>Moreover, feature flags are a stepping stone toward <strong>trunk-based development</strong> flow, delivering development teams from the pain of long living feature branches and complicated merges. Instead, all pending features can be on the main branch, behind flags.</p><h3>Local flags VS Izanami</h3><p><strong>Local flags</strong> are the most common implementation of feature flags. They are defined entirely in application code, it could be through the use of if/else statement with environment variables, using dedicated library…</p><p>While local flags are a good way to get started and a great solution for simple needs, Izanami offers an alternative by allowing to <strong>centralize flags</strong>. This comes with advantages:</p><ul><li>Flags can be <strong>shared between applications</strong>, and technologies</li><li>Flag activation condition can be <strong>changed without any impact</strong> on client applications</li><li>All <strong>flags are in the same places</strong>, which ease their administration and monitoring</li><li>Toggling a flag has <strong>immediate effect on all consumers.</strong></li></ul><h3>Izanami</h3><p>As we’ve seen, Izanami is a centralized feature flags solution. It allows defining and exposing feature flags easily.</p><p>Feature flags can either be simple toggles or have more complex activation conditions, based on date, users, or even custom scripts.</p><p>Izanami exposes flags through HTTP, allowing any application to retrieve flag(s) state(s).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kxMXS-JUGxtW0g27RX2Q0g.png" /><figcaption>Izanami integrates easily with many languages</figcaption></figure><p>Last but not least, Izanami is Open Source (under Apache 2 license), meaning that you can suggest improvements or help making them happen !</p><h3>What changes with v2</h3><p>This new Izanami version focuses on feature flags. It introduces some <strong>enterprise-friendly features</strong>, such as multi tenancy, organization of features by projects and tags and support for environments (and much more) through contexts. Feature flags are also way more flexible, since they can now have several activation conditions.</p><p>This new version also reimplements script features using WASM through the use of <a href="https://extism.org/">Extism</a> and <a href="https://maif.github.io/wasmo/">WASMO</a>.</p><p>WASM makes script execution <strong>completely sandboxed</strong> and allows writing features using a variety of languages (Go, Rust, Js, …).</p><p>While V2 is a complete rewrite of Izanami, it keeps compatibility with existing clients, except for some rare edge cases.</p><p>However, a new Java client come with this version, which has fewer dependencies and provides more flexibility, especially regarding error strategies and cache management.</p><p>Another big change is the <strong>choice of Postgres as a database</strong>, which allows leveraging its specifics features for better performances.</p><p>A/B testing is absent for v2 for now, however we plan to add it soon.</p><p>Finally, Izanami v2 does not include distributed configuration management. We abandoned this feature because there are many open-source solutions that do it very well, such as Spring cloud config, Consul, ZooKeeper…</p><h3>What’s next</h3><p>While v2 is production ready, there are some big features coming:</p><ul><li><strong>Audit log</strong> : this will allow monitoring exactly how a feature flag was modified by users and accessed by client. This could be used to understand how a flag ended up in a given state, or to make sure that a feature is not used anymore before deleting it.</li><li><strong>JavaScript client</strong>: we plan to rewrite JavaScript client to leverage full power of Izanami v2.</li><li><strong>A/B testing</strong>: A/B testing is not present in v2 yet, but we plan to add an improved version of it, as we did for feature flags.</li></ul><p>To learn more, go to <a href="https://maif.github.io/izanami/">Izanami documentation</a> or <a href="https://github.com/MAIF/izanami">Github repository</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62c753b445be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/announcing-izanami-v2-62c753b445be">Announcing Izanami v2</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rewriting a python package: The journey towards Melusine v3.0]]></title>
            <link>https://medium.com/oss-by-maif/rewriting-a-python-package-the-journey-towards-melusine-v3-0-c57e2b6cee45?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/c57e2b6cee45</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[nlp]]></category>
            <dc:creator><![CDATA[Hugo Perrier]]></dc:creator>
            <pubDate>Tue, 12 Mar 2024 14:25:30 GMT</pubDate>
            <atom:updated>2024-03-12T14:25:30.746Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KDnF7kfEclsORy-VMksCPg.jpeg" /><figcaption>Streamline your email processing workflow with Melusine.</figcaption></figure><p>Melusine is an email processing Python package developed by MAIF. Originally designed for email routing, Melusine has evolved over the years to encompass a wider range of email processing tasks.</p><p>As the Data Factory at MAIF matured, the need for a modern, maintainable, and extensible code base became apparent. This led to a <strong>complete rewrite</strong> of Melusine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*juyQn2rqay32uuWPQB7caw.png" /><figcaption>Evolution of automatic email processing at MAIF over the years (only the core functionalities are open-sourced, not the applications).</figcaption></figure><p>In this article, I’ll describe some of the pain points encountered while maintaining the open-source package and using it in a production environment.</p><h3>What is the problem ?</h3><p>If you have been running a software for several years, these situations may sound familiar to you:</p><blockquote><strong><em>Business analyst:</em></strong><em> “Could we add this simple rule to improve email qualification?”<br></em><strong><em>Data Scientist :</em></strong><em> “Sure, we will have to modify 30 files in five different repositories. It should take about 6 months”</em></blockquote><blockquote><strong><em>MAIF representative:</em></strong><em> “Why is this email marked as urgent?”<br></em><strong><em>Data Scientist:</em></strong><em> “Well it could be the model… or business rules… may be both? We are not sure”</em></blockquote><blockquote><strong><em>New developer: </em></strong><em>“What does this line of code do?”<br></em><strong><em>Confirmed developer:</em></strong><em> “It was there when I arrived and I’m affraid to delete it”</em></blockquote><p>Managing a large code base over time is full of challenges, but in the present article I’d like to focus on modernity, modularity, continuous integration and robustness.</p><h3>Modernity</h3><blockquote><em>“Bag-of-word, Tf-Idf, Word2Vec, GloVe, FastText, RNN, LSTM, Transformers, BERT, GPT, Llama, Mistral, …”</em></blockquote><p>With Melusine, <a href="https://www.deeplearning.ai/resources/natural-language-processing/">Natural Language Processing</a> (NLP) is used to process emails. For example, we can detect if someone is angry based on the content of the email. The challenge is that,</p><blockquote>since 2018, the NLP landscape has changed drasticaly!</blockquote><p>We went from data scientists running their custom preprocessing code and training models from scratch to largely available off-the-shelf large language models.</p><p>The new Melusine is designed to be deep-learning framework agnostic, ensuring compatibility with the latest advancements in NLP. The usage of proven design patterns made sure that users could easily switch from a machine learning package to another.</p><p>Experience it yourself with this <a href="https://maif.github.io/melusine/tutorials/07_BasicClassification/">tutorial</a> on emails Zero Shot Classification using Melusine and the HuggingFace transformers package.</p><p>We also focused on where Melusine shines: dealing with the specificities of email data with features like email conversation segmentation or signature text extraction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*7nX2jdYfdqLCRKFuaz3W9Q.png" /></figure><h3>Modularity</h3><blockquote><em>“I just had a call with the business, this year they would like to add 27 new use-cases of email automation”</em></blockquote><p>As the scope of Melusine’s functionality expanded to encompass various mailboxes and unique processing requirements, the existing code base has grown increasingly complex.</p><blockquote>Being able to deliver new features without breaking existing ones is paramount for Melusine.</blockquote><p>To address this challenge, while rewriting Melusine, we embraced the <a href="https://realpython.com/solid-principles-python/">Single Responsibility Principle</a> (SRP) as a guiding principle. The SRP dictates that each part of the code should have a single responsibility, performing a specific task and minimizing interdependencies.</p><p>In practice, the SRP has been implemented in Melusine v3.0 by organizing the code into a pipeline framework. Each pipeline step handles a distinct task, such as text cleaning or detection. For instance, one step could segment an email conversation, while another applies a machine learning model to identify dissatisfaction in an email.</p><p>This modular approach has yielded several benefits:</p><ol><li><strong>Facilitated Onboarding:</strong> New developers can work on a module directly without the need to dive into the entire code base.</li><li><strong>Secured Deployments: </strong>As coupling is minimized, the risk of breaking an existing feature while working on a new one is limited.</li><li><strong>Enhanced Collaboration: </strong>Code reviews are much simpler on a modular code and developers can spend more time discussing the general design rather than specific code blocks.</li><li><strong>Code Reusability:</strong> At MAIF, we use Melusine to process emails from different mailboxes. Building up on generic code blocks greatly simplifies the maintenance of out applications.</li></ol><p>Check out this <a href="https://maif.github.io/melusine/tutorials/00_GettingStarted/">tutorial</a> explaining how to build an email processing pipeline with Melusine.</p><h3>Continuous Integration</h3><blockquote><em>“We got a really cool external contribution to the open-source package. I’m just worried that it could impact our production code if we integrate it”</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_touDIDWPCfo-iJM0v6zPA.png" /><figcaption>Test automation with GitHub Actions</figcaption></figure><p>Data Science and NLP are highly dynamic fields, with new tools and updates being released on a daily basis. In this context, developers may be tempted to add every emerging functionality to their packages to chase the state of the art. However, this approach can lead to dependency conflicts, API breaking changes, and a constantly outdated codebase. To address these challenges, MAIF focused on three key aspects during the rewrite of Melusine:</p><ol><li><strong>Limited Mandatory Dependencies:</strong> To minimize the impact of dependency changes, Melusine v3.0 separates features requiring external packages from the core modules. These external dependencies are then made <a href="https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#optional-dependencies">optional</a>, allowing users to select only what they need.</li><li><strong>Significant Test Coverage:</strong> To ensure the stability and reliability of Melusine, MAIF implemented a comprehensive testing strategy, achieving over 95% test coverage.</li><li><strong>Tested Tutorials:</strong> Instead of notebooks, the tutorials in Melusine v3.0 are written as unit tested python files and incorporated in the <a href="https://maif.github.io/melusine/">documentation</a>.</li></ol><p>With these measures in place, we are much more confident regarding the robustness and maintenability of the package over time and we will be able to focus our energy on evolutions rather than fixing bugs.</p><h3>Robustness</h3><p>In its early days, the MAIF Data Factory primarily relied on external developers to build its codebase. As these developers came and went, their varying coding styles introduced inconsistencies and made it challenging to onboard new developers. To address this issue, MAIF undertook a comprehensive overhaul of its Data Factory, focusing on four key aspects:</p><ol><li><strong>People: </strong>MAIF recruited a diverse team of skilled professionals, including data scientists, software developers, operations engineers, and project managers. New collaborators brought a much needed experience to the Data Factory.</li><li><strong>Technical Expertise: </strong>MAIF invested in developing its in-house NLP and data science expertise and kept learning from maintaining and developing open-source packages.</li><li><strong>Industrialization:</strong> The Data Factory’s deployment process transitioned from manual to highly automated workflows. This involved implementing rigorous test coverage, code quality checks, and pre-commit hooks.</li><li><strong>Organizational Structure: </strong>MAIF revamped its organizational structure, moving away from a startup-like approach with limited project management and sporadic business interactions. The Data Factory adopted a more structured organizational model, featuring agile teams with product owners, facilitators, and systematic interactions with end-users and business representatives.</li></ol><p>By implementing these transformative changes, MAIF instilled a culture of best practices and a more consistent coding philosophy within the Data Factory, laying a solid foundation for the development of the new Melusine.</p><h3>Conclusion</h3><p>In this article, we’ve presented the pitfalls of the maintainance of an open-source package and the challenges of running an application in production and we have shared the solutions we implemented to address them during Melusine’s rewrite.</p><p>Initiating a complete code rewrite is a daunting task but also a remarkable opportunity to enhance our coding abilities. The journey towards Melusine v3.0 has profoundly impacted MAIF DataFactory’s team and resulted in long lasting transformations.</p><p>MAIF is eager to share these valuable insights with the community by open-sourcing the <a href="https://github.com/MAIF/melusine">new version of Melusine</a>, paving the way for continued innovation and collaboration.</p><h3>About the author</h3><p><em>I grew up in the French Alps, studied Physics / Nuclear Engineering in Switzerland, Sweden and England, and I’ve been working as a Data Scientist since 2018 at Quantmetry and MAIF. I am also a big fan of wakeboarding and board games :)</em></p><p>Follow me on <a href="http://www.linkedin.com/in/hugoperrier">LinkedIn</a>.<br>Leave a star for <a href="https://github.com/MAIF/melusine">Melusine on GitHub</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c57e2b6cee45" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/rewriting-a-python-package-the-journey-towards-melusine-v3-0-c57e2b6cee45">Rewriting a python package: The journey towards Melusine v3.0</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eurybia: MAIF releases a new open-source solution for quality IA models in production]]></title>
            <link>https://medium.com/oss-by-maif/eurybia-maif-releases-a-new-open-source-solution-for-quality-ia-models-in-production-57bd0266a77e?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/57bd0266a77e</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Thomas Bouche]]></dc:creator>
            <pubDate>Thu, 05 May 2022 15:06:49 GMT</pubDate>
            <atom:updated>2022-05-11T11:48:27.584Z</atom:updated>
            <content:encoded><![CDATA[<p>MAIF, a French mutual insurance company (est. 1934), has been contributing to open source for a few years. Since 2019, we share our work in the field of artificial intelligence, our first release was <a href="https://github.com/MAIF/melusine"><strong>Melusine</strong></a>, for french langage email processing and our second was <a href="https://github.com/MAIF/shapash"><strong>Shapash</strong></a>, to make machine learning interpretable and understandable by everyone.</p><p>We are now releasing <strong>Eurybia</strong>, a python library to ensure quality of machine learning model in production by detecting model drift. Eurybia also addresses challenges of <strong>industrialisation </strong>and<strong> maintainability </strong>of IA over time. Thus, it contributes for a better model monitoring, model auditing and more generally <strong>AI governance</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*7zpHegFlmGm3P9DImJN_1A.jpeg" /><figcaption>Eurybia logo by MAIF</figcaption></figure><h3>Elements of context</h3><p>More and more machine learning models are being deployed into production environments. A key step for deployment is to <strong>secure the data</strong> that will be used for the prediction model. This is crucial, notably when training and production data sources differ.</p><p>While most models have been built from historical data and are static, data are usually dynamic, meaning that they change over time and so do the prediction capabilities. To have a controlled use of AI, it is important to <strong>detect these changes</strong> to determine if they are problematic, track performance over time, and consider re-training the model if necessary.</p><h3>Why have we made Eurybia?</h3><p>At MAIF, as an insurer, we’ve been using data for a long time, notably to simultaneously offer the best personalized advice to our customers and control insurance risks. Because of our history, as a committed mutual insurance company and because we believe that companies should be responsible for their use of data, we are particularly involved in AI governance.</p><p>The visualization of the life cycle of a machine learning model can ease the understanding of Eurybia importance. During their life, ML models go through the following phases: Model learning, Model deployment, Model monitoring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JfmSQHO-YML6egTUdSHifg.png" /><figcaption>life cycle machine learning model</figcaption></figure><p>To ensure that models perform in production as well as they did in training, it is important to verify that data are consistent and that<em> </em>features distributions are similar.</p><p>We want to closely monitor our models in production, notably to detect as early as possible when models are likely to provide less suitable recommendations.</p><p>At MAIF, we use Eurybia to:</p><ul><li><strong>Secure model deployment</strong> by detecting any inherent data problems</li><li>Help data analysts, data engineers and data scientists to<strong> collaborate</strong> for data validation before deploying a model into a production environment</li><li><strong>Make it easier and faster</strong> for MAIF’s data scientists to analyze data drift</li><li>Know whether it is necessary to <strong>re-train</strong> the model</li><li>Save <strong>drift monitoring</strong> reports for drift monitoring, for consultation following an e-mail alert or another specific need</li></ul><h3>What is Eurybia?</h3><p>Eurybia is a Python library which aims to help detecting drift and validate data before putting a model in production (named deployed model).</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*I8xUqyDEd287FWym0PDh_w.gif" /><figcaption>Eurybia Gif</figcaption></figure><p>Underneath, you’ll see a short description of elements which are referred to in this article.</p><ul><li><strong>Data Validation</strong> : Validate that data used for production prediction are similar to training data or test data before deployment.</li><li><strong>Data drift</strong> : Evolution of the production data over time compared to training or test data before deployment.</li><li><strong>Model drift</strong> : Model performances’ evolution over time due to change in the target feature statistical properties (<strong>Concept drift</strong>), or due to change in data (<strong>Data drift</strong>).</li></ul><p>For technical definitions, we recommend to read the bibliography.</p><p>For Data Validation and Data Drift, Eurybia works mainly with a <strong>binary classification model</strong> (named datadrift classifier) that tries to predict whether a sample belongs to the training/baseline dataset or to the production/current dataset.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P-eHhByJHCjKUWiKY-lkVw.png" /><figcaption>How the datadrift classifier works</figcaption></figure><p>The <strong>explainability</strong> of this datadrift classifier provides higher scores to features that are important for drift. When combined with the initial deployed model features importances, this explainability reationalizes further analysis.</p><p>Eurybia thus allows its users to :</p><ul><li>Get a quick overview of features that changed the most to <strong>prioritize study</strong> of drift</li><li><strong>Put into perspective</strong> the evolution of features with their importance for the deployed model. To study in priority drift on features with the most influence on the model</li><li>Display each feature and its <strong>distribution</strong></li><li>Display the difference between the <strong>predicted probabilities distributions</strong> respectively based on the baseline dataset and the production dataset</li><li>Have a performance metric for data drift and <strong>track it over time</strong></li></ul><p>Eurybia also has additional features that allow to :</p><ul><li>Analyze <strong>data consistency</strong> by checking if features are the same between baseline and production dataset, as well as features modalities</li><li>Detect model drift by <strong>displaying model performance over time</strong> (a section we would like to develop in future Eurybia releases)</li><li><strong>Save a dynamic report</strong> that allows collaboration between colleagues, drift analysis, and for audit purposes</li></ul><p>Eurybia can be used for all kinds of use cases and domains : health, business, marketing, …</p><p>Please visit <a href="https://github.com/MAIF/eurybia"><strong>Eurybia’s GitHub</strong></a> : there, you will find more exhaustive documentation of the library’s features as well as a <a href="https://eurybia.readthedocs.io/en/latest/report.html"><strong>demo</strong></a> of the dynamic report for a quick test! Please do not hesitate to give us a star on GitHub if you like the project!</p><p>Maif open source several libraries and not only data science libraries, you can visit them <a href="https://maif.github.io/"><strong>here</strong></a>.</p><h3>Further readings</h3><p>We have quickly introduced the notion of drift. If you wish to learn more about drift, I recommend the following resources :</p><ul><li>Drift classification and retraining: <a href="https://towardsdatascience.com/model-drift-in-machine-learning-models-8f7e7413b563">https://towardsdatascience.com/model-drift-in-machine-learning-models-8f7e7413b563</a></li><li>Concept drift characterization: <a href="https://arxiv.org/pdf/1511.03816.pdf">https://arxiv.org/pdf/1511.03816.pdf</a></li><li>Mathematical view for different types of drifts : <a href="https://medium.com/data-from-the-trenches/a-primer-on-data-drift-18789ef252a6">https://medium.com/data-from-the-trenches/a-primer-on-data-drift-18789ef252a6</a></li><li>Data drift detection: <a href="https://arxiv.org/pdf/2012.09258.pdf">https://arxiv.org/pdf/2012.09258.pdf</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57bd0266a77e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/eurybia-maif-releases-a-new-open-source-solution-for-quality-ia-models-in-production-57bd0266a77e">Eurybia: MAIF releases a new open-source solution for quality IA models in production</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Eurybia : Une nouvelle solution #OSSByMAIF pour une Intelligence Artificielle plus maîtrisée]]></title>
            <link>https://medium.com/oss-by-maif/eurybia-une-nouvelle-solution-ossbymaif-pour-une-intelligence-artificielle-plus-ma%C3%AEtris%C3%A9e-843e651a2ced?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/843e651a2ced</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Thomas Bouche]]></dc:creator>
            <pubDate>Thu, 05 May 2022 15:05:07 GMT</pubDate>
            <atom:updated>2022-05-05T15:05:07.842Z</atom:updated>
            <content:encoded><![CDATA[<h3>Eurybia : Une nouvelle solution #OSSByMAIF pour une Intelligence Artificielle plus maîtrisée</h3><p>La MAIF contribue à l’open source depuis plusieurs années et, depuis 2019, nous partageons nos travaux dans le domaine de l’intelligence artificielle. Nous avons libéré <a href="https://github.com/MAIF/melusine"><strong>Melusine</strong></a>, pour le traitement des emails en langue française, puis <a href="https://github.com/MAIF/shapash"><strong>Shapash</strong></a>, pour rendre l’intelligence artificielle plus transparente et compréhensible par tous.</p><p><strong>Aujourd’hui, nous vous présentons </strong><a href="https://github.com/MAIF/eurybia"><strong>Eurybia</strong></a><strong> !</strong></p><p>Cette librairie Python garantit la qualité des modèles de machine learning en production (c’est à dire une fois qu’il sont déployés au sein de l’entreprise) en détectant leur dérive et répond ainsi aux défis de l’<strong>industrialisation</strong> et de la <strong>maintenabilité</strong> de l’IA dans le temps. Elle contribue à une meilleure surveillance des modèles, à leur audit et plus généralement à la <strong>gouvernance de l’IA</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/1*7zpHegFlmGm3P9DImJN_1A.jpeg" /><figcaption>Eurybia par MAIF</figcaption></figure><h3>Les enjeux pour une IA de qualité : sécuriser et de maintenir les modèles de machine learning</h3><p>En effet, de plus en plus de modèles de machine learning sont déployés en production. Une étape clé du déploiement consiste à <strong>sécuriser la qualité des données</strong> qui seront utilisées pour la prédiction ou recommandation poussée par le modèle de machine learning. Cette étape est cruciale, notamment lorsque les sources des données d’apprentissage et de production diffèrent.</p><p>Alors que la plupart des modèles sont construits à partir de données historiques qui sont statiques, les données de production sont généralement dynamiques : elles évoluent dans le temps, et donc les prédictions/recommandations qui s’appuient sur ces données évoluent aussi. Pour avoir une utilisation contrôlée de l’IA, il est important de <strong>détecter ces écarts</strong> afin de déterminer s’ils posent problème, suivre les performances dans le temps, et envisager de ré-entraîner le modèle si nécessaire.</p><h3>Eurybia, un outil qui répond aujourd’hui à nos besoins …</h3><p>Au sein de la MAIF, nous avons évidemment un <strong>usage historique des données</strong>, pour proposer un conseil personnalisé à nos sociétaires, mais aussi pour maîtriser nos risques. De par notre histoire, en tant que mutuelle engagée et parce que nous pensons que les entreprises doivent être responsables de leur utilisation des données, nous sommes particulièrement impliqués dans la gouvernance de l’IA.</p><p>Un modèle de <em>machine learning </em>passe par les phases suivantes au fil de son cycle de vie : Apprentissage du modèle, Déploiement du modèle, Monitoring du modèle — <em>voir schéma ci-dessous.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JfmSQHO-YML6egTUdSHifg.png" /><figcaption>Cycle de vie d’un modèle de machine learning</figcaption></figure><p>Pour s’assurer que les modèles fonctionnent en production aussi bien qu’à l’apprentissage, il est important de vérifier que les données sont cohérentes et que les distributions des variables du modèle sont similaires.</p><p>Nous souhaitons suivre de près nos modèles en production, notamment pour détecter au plus tôt lorsque les modèles sont susceptibles de fournir des recommandations moins adaptées.</p><p><strong>A la MAIF, nous utilisons Eurybia pour :</strong></p><ul><li><strong>Sécuriser la mise en production</strong> de modèle en détectant tout problème inhérent aux données</li><li>Aider les data analysts, data engineers et data scientists à <strong>collaborer</strong> pour valider les données avant de déployer un modèle en production.</li><li><strong>Faciliter et accélérer</strong> l’analyse de la dérive des données par les data scientists de la MAIF.</li><li>Savoir s’il est nécessaire de <strong>ré-entraîner</strong> le modèle</li><li><strong>Sauvegarder des rapports</strong> pour le suivi de la dérive, pour une consultation suite à une alerte e-mail ou un autre besoin spécifique.</li></ul><h3>…et que nous libérons en open-source afin de contribuer à une IA plus maîtrisée</h3><p>Eurybia est une librairie Python qui a pour but d’aider à détecter les dérives et à valider les données avant de mettre un modèle en production.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*I8xUqyDEd287FWym0PDh_w.gif" /><figcaption>Démo du rapport Eurybia</figcaption></figure><p>Dans cet article, nous ferons référence à ces différents termes :</p><ul><li><strong>Validation des données</strong> : Valider que les données utilisées pour la prédiction en production sont similaires aux données d‘apprentissage avant le déploiement.</li><li><strong>Dérive des données</strong> : Évolution des données de production dans le temps par rapport aux données d’apprentissage.</li><li><strong>Dérive du modèle</strong> : Évolution des performances du modèle dans le temps, en raison d’un changement des propriétés statistiques de la variable cible (<strong>dérive de concept</strong>), ou en raison d’un changement des données (<strong>dérive des données</strong>).</li></ul><p><em>Pour les définitions techniques, nous vous recommandons de lire la bibliographie.</em></p><p>Pour la validation des données et la dérive des données, Eurybia fonctionne principalement grâce à un <strong>modèle de classification binaire</strong> (appelé <em>datadrift classifier</em>). Ce modèle tente de prédire si un individu appartient aux données d’entraînement ou aux données en production, c’est à dire de déterminer dans quel mesure ces deux jeux de données sont différents. Si ce <em>datadrift classifier</em> a des performances élevés, alors la dérive est importante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GN1jh-TpRHZG0KW1Mz0qAw.png" /><figcaption>Fonctionnement principal d’Eurybia</figcaption></figure><p>L’<strong>explicabilité</strong> du <em>datadrift classifier</em> fournit des résultats plus élevés aux variables qui sont importantes pour la dérive. Combinée à l’importance des variables du modèle déployé, cette explicabilité permet de prioriser l’analyse.</p><p><strong>Eurybia permet ainsi :</strong></p><ul><li>D’avoir un aperçu rapide des variables qui ont le plus changé pour <strong>prioriser l’étude</strong> de la dérive.</li><li>De <strong>mettre en perspective</strong> l’évolution des variables avec leur importance pour le modèle déployé. Et donc d’étudier en priorité la dérive des variables ayant le plus d’influence sur le modèle.</li><li>D’afficher les <strong>distributions</strong> variable par variable</li><li>D’afficher la différence de distribution entre les <strong>probabilités de la prédiction</strong> du modèle sur le jeu de données d’apprentissage et le jeu de données en production.</li><li>D’avoir des métriques qui indiquent le niveau de dérive des données et les <strong>suivre dans le temps</strong>.</li></ul><p><strong>Eurybia dispose également de fonctionnalités supplémentaires qui permettent de :</strong></p><ul><li>Analyser la <strong>cohérence des données</strong> en vérifiant si les variables sont les mêmes entre le jeu de données d’apprentissage et le jeu de données de production, ainsi que les modalités des variables.</li><li>Détecter les dérives du modèle en <strong>affichant les performances du modèle</strong> dans le temps. (Pour bien répondre à la problématique du modèle drift, nous souhaitons développer le concept drift dans les prochaines versions d’Eurybia).</li><li><strong>Sauvegarder un rapport dynamique</strong> qui facilite la collaboration entre collègues, et qui permet d’avoir un livrable à des fins d’audit.</li></ul><p>Eurybia fonctionne pour tout type de cas d’usage. Il peut être utilisé dans le domaine de la santé, l’économie, marketing, …</p><p>N’hésitez pas à vous rendre sur le GitHub de <a href="https://github.com/MAIF/eurybia"><strong>Eurybia</strong></a> : vous y trouverez une documentation exhaustive des fonctionnalités proposées par la librairie ainsi qu’une <a href="https://eurybia.readthedocs.io/en/latest/report.html"><strong>demo</strong></a> du rapport Eurybia pour un test rapide ! Et n’hésitez pas à mettre une étoile sur GitHub si vous aimez le projet !</p><p>La MAIF contribue à plusieurs librairies open source, et pas que des librairies de data science. Vous pouvez consultez le catalogue <a href="https://maif.github.io/"><strong>ici</strong></a>.</p><h3>Lectures complémentaires</h3><p>Nous avons rapidement introduit la notion de dérive. Si vous souhaitez en savoir plus sur la dérive, je vous recommande les ressources suivantes :</p><ul><li>Drift classification and retraining: <a href="https://towardsdatascience.com/model-drift-in-machine-learning-models-8f7e7413b563">https://towardsdatascience.com/model-drift-in-machine-learning-models-8f7e7413b563</a></li><li>Concept drift characterization: <a href="https://arxiv.org/pdf/1511.03816.pdf">https://arxiv.org/pdf/1511.03816.pdf</a></li><li>Mathematical view for different types of drifts : <a href="https://medium.com/data-from-the-trenches/a-primer-on-data-drift-18789ef252a6">https://medium.com/data-from-the-trenches/a-primer-on-data-drift-18789ef252a6</a></li><li>Data drift detection: <a href="https://arxiv.org/pdf/2012.09258.pdf">https://arxiv.org/pdf/2012.09258.pdf</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=843e651a2ced" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/eurybia-une-nouvelle-solution-ossbymaif-pour-une-intelligence-artificielle-plus-ma%C3%AEtris%C3%A9e-843e651a2ced">Eurybia : Une nouvelle solution #OSSByMAIF pour une Intelligence Artificielle plus maîtrisée</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mélusine, un retour d’expérience MAIF !]]></title>
            <link>https://medium.com/oss-by-maif/m%C3%A9lusine-un-retour-dexp%C3%A9rience-maif-1ce5cd50802b?source=rss----75e417c6fe68---4</link>
            <guid isPermaLink="false">https://medium.com/p/1ce5cd50802b</guid>
            <category><![CDATA[customer-experience]]></category>
            <category><![CDATA[email]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[nlp]]></category>
            <dc:creator><![CDATA[Tiphaine Fabre]]></dc:creator>
            <pubDate>Tue, 30 Nov 2021 19:08:06 GMT</pubDate>
            <atom:updated>2021-11-30T19:08:06.330Z</atom:updated>
            <content:encoded><![CDATA[<h3>Mélusine, un retour d’expérience MAIF !</h3><p>Cela fait maintenant presque trois ans que nous nous sommes lancés dans l’optimisation du traitement des flux mails entrants à MAIF. Nous avions à cette occasion libéré en Open Source la <a href="https://github.com/MAIF/melusine">librairie Mélusine</a> permettant la qualification des emails entrants grâce à des techniques avancées de traitement du langage, développée avec notre partenaire Quantmetry.</p><p>Il était donc temps pour nous de revenir sur le chemin parcouru mais également vous partager nos ambitions pour les années à venir !</p><h3>Pourquoi avoir créé Mélusine ? C’était quoi le besoin ?</h3><p>Commençons par le commencement ! MAIF, c’est plus de 3 millions de sociétaires et plus de 15000 mails reçus <strong>par jour. </strong>C’est donc beaucoup de mails à traiter par nos gestionnaires et conseillers. Il nous fallait trouver une solution pour<strong> soulager leur charge de travail et réduire le délai de réponse à nos sociétaires.</strong></p><h4>Le routage des mails</h4><p>Une des premières problématiques rencontrées était <strong>le routage des mails</strong>. Et par routage, on entend distribuer le mail à l’entité compétente pour le traiter.</p><p>MAIF utilise des <strong>boites à lettres génériques</strong> pour les différents métiers de l’assurance : la gestion d’un sinistre, sa déclaration ou encore la gestion des contrats. Dans ces métiers, se détaillent de nombreuses spécialités comme, par exemple, la gestion de contrats automobiles, navigation ou habitation. Ces spécialités nécessitent une expertise de la part de nos utilisateurs. Un conseiller expert en contrat automobile est rarement expert en contrat navigation. Nous avions donc besoin de comprendre le contenu du mail pour l’attribuer au conseiller expert compétent et limiter les rebonds qui peuvent rallonger les délais de réponse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*FgzebakIvFYSqdKIWP9eug.png" /></figure><p>Aujourd’hui, dans le domaine « Contrats », Mélusine permet un routage vers le bon expert dans plus de 84% des cas. On a ainsi pu voir <strong>une réduction du délai de réponse au sociétaire de 40%</strong> dans certains domaines d’expertise.</p><h3>Une évolution constante du périmètre et des améliorations de l’existant.</h3><p>A l’initiale de ce projet, en 2018, nous avions préféré cibler les mails du domaine « Contrats » pour faire la preuve de nos développements et montrer la valeur que pouvait apporter l’Intelligence Artificielle dans la gestion des flux entrants mails. Grâce à cette première expérience positive sur un périmètre restreint, nous avons suscité l’intérêt des utilisateurs et avons rapidement entamé des travaux sur les mails du domaine « Sinistres ». Fin 2019, nous faisions notre première mise en production sur ce domaine.</p><p>Depuis, nous n’arrêtons pas d’étendre le périmètre de Mélusine dans le traitement de flux : de nombreux cas d’usages, traitements de flux autres que mails (ex : commentaires d’experts), améliorations des cas d’usages existants.</p><h4>Mélusine, ce n’est pas que le routage !</h4><p>Grâce aux technologies utilisées pour l’analyse du langage, nous avons pu enclencher de nombreux types de traitements : de la priorisation, de la clôture de mails, de la réponse automatique, etc…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*6BLkCkJTGZYJ8NRL6CU46Q.png" /></figure><p>En effet, au-delà du routage, un mail contient de nombreuses informations à mettre en valeur ou utiliser pour faciliter le quotidien de nos utilisateurs. Les différentes briques de la librairie Mélusine Open source peuvent alors être réutilisées à volonté.</p><p>Une fois la segmentation du mail réalisée (identification des signatures, remerciements, corps du mail etc…), on peut cibler la partie du mail qui nous intéresse et entraîner un modèle d’intelligence artificielle (réseau de neurone) pour réaliser le traitement souhaité.</p><h4>Des réseaux de neurones pour tous les cas d’usages ?</h4><p>Dans la majorité de nos cas d’usages, on répond à une question « simple » qui nécessite une réponse binaire (oui, ou: non?). Pour vous donner un exemple concret, aujourd’hui en production, on veut savoir si le message nécessite une action ou non du gestionnaire/conseiller. Le modèle devra alors répondre « Information » ou « Action ».</p><p>On peut alors aborder la problématique par des méthodes de classification supervisée, i.e. notre modèle s’entrainera avec des données pour lesquelles il connait déjà les réponses. Cela nécessite, bien sûr, en amont, la préparation d’un jeu de données.</p><p>Nous nous appuyons systématiquement sur les métiers pour réaliser cette préparation car seuls eux peuvent retranscrire les pratiques du quotidien. Selon la complexité du cas d’usage, le volume de messages à annoter nécessaire varie d’une centaine à quelques milliers par catégorie à prédire.</p><p>Ce processus permet de traiter des messages de formes très différentes, avec une infinité de formulations du langage. On peut alors couvrir de grands volumes de données en production. Mais ce genre de méthodes probabilistes peut aussi être source d’erreur. C’est pourquoi nous le couplons parfois avec des règles métiers pour sécuriser la réponse apportée en production. Plus particulièrement, lorsqu’on veut clôturer un mail informatif, il est impératif qu’aucun message ne soit clôturé à tort.</p><p>Certains cas d’usages sont également assez simples pour être traités uniquement avec des règles métiers. Par règles métiers, on entend la recherche de motifs fixes dans le texte à l’aide d’expressions régulières. Par exemple, pour détecter un remerciement chaleureux, nous rechercherons dans le message le motif « merci beaucoup » ou le mot « infiniment » alors qu’on exclura des mots comme « inacceptable ».</p><h3>Un changement des pratiques des gestionnaires/conseillers au quotidien</h3><p>Depuis la mise en production de Mélusine, nous avons pu faire la preuve que l’intelligence artificielle peut opérer sans faire de l’ombre à l’activité de nos utilisateurs. Nous souhaitions d’ailleurs à cette occasion, recueillir les témoignages de nos utilisateurs sur leur quotidien avec Mélusine. Deux de nos gestionnaires se sont prêtées au jeu des interviews.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FHiXE4W6G-Eg%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DHiXE4W6G-Eg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FHiXE4W6G-Eg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c7c370bac53bf610fd08f630bb1c81e9/href">https://medium.com/media/c7c370bac53bf610fd08f630bb1c81e9/href</a></iframe><p>Julie et Annabelle évoquent notamment comment Mélusine a changé leur quotidien grâce à :</p><ul><li>La <strong>priorisation des mails</strong> : nous pouvons détecter des messages à caractère d’urgence ou au contraire déprioriser certains mails. Cette information est portée à l’attention du gestionnaire/conseiller qui adapte son activité en fonction.</li><li>La <strong>clôture des mails</strong> : les mails à caractère informatifs qui ne nécessitent pas d’action peuvent être clôturés directement. Ils s’affichent toutefois aux yeux de l’utilisateur mais sans nécessiter d’actions. L’utilisateur peut alors lire son contenu rapidement.</li><li>La <strong>réponse automatique: </strong>de manière très marginale, une réponse automatique est apportée pour certains mails qui ne requièrent pas d’accompagnement de la part d’un conseiller. Comme la clôture, le mail émie automatiquement s’affiche dans l’interface sans nécessiter d’actions.</li><li>Le <strong>confort</strong> : au-delà de la priorisation ou la clôture, un gros travail a été réalisé sur la façon d’apporter le plus d’informations possibles sur l’interface du gestionnaire/conseiller. Ainsi, un champ texte est enrichi pour leur donner une première lecture rapide du mail. Apparaissent alors l’expéditeur du mail, les cas d’usages détectés par l’IA (ex : taux d’humidité, rendez-vous détecté, mise en place d’aide à domicile etc.) et le début du mail.</li></ul><p>Autant d’informations qui permettent à l’utilisateur de comprendre rapidement les actions à mener et organiser sa journée.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FzU8Li9mQB10%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DzU8Li9mQB10&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FzU8Li9mQB10%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/9ff9c9cae4abc50beafcfd5a0f137b5c/href">https://medium.com/media/9ff9c9cae4abc50beafcfd5a0f137b5c/href</a></iframe><p>Tous ces apports de l’IA se sont traduits par une adaptation du quotidien des utilisateurs, qui se sont rapidement emparés des informations fournies pour organiser plus sereinement leur journée de travail. Ces améliorations allègent leur activité d’actions simples et répétitives, ce qui les rend plus disponibles pour répondre aux sociétaires.</p><h3>Les perspectives pour l’Intelligence Artificielle</h3><p>Les volumes de flux emails étant en constante croissance, nous avons à cœur d’étendre toujours plus le périmètre de Mélusine. Cela peut passer par l’amélioration de la détection de cas d’usages existants, la mise en place de nouveaux cas d’usages ou par l’exploitation de nouveaux types de données !</p><p>En effet, un mail ce n’est pas que du texte ! Ce sont aussi des pièces jointes. En cette fin d’année 2021, nous mettrons notre premier modèle de typage de pièces jointes en production. L’utilisateur pourra ainsi rapidement savoir si le document associé est une facture, un devis etc… Combiner le contenu du texte et le type de documents élargira également le périmètre de nos cas d’usages.</p><p>Par exemple, aujourd’hui nous ne clôturons que des mails informatifs sans pièce jointe. Jusqu’à maintenant, lorsque le mail contenait une pièce jointe, on ne savait pas ce qu’elle contenait. On ne voulait pas prendre le risque de clôturer un mail contenant des documents importants.</p><p>Mais ! Vous avez sûrement déjà fait l’expérience de ces mails avec des signatures/logos en pièces jointes…elles ne vous sont que rarement utiles. Lorsqu’on saura identifier ces documents à faible valeur, on pourra clôturer un plus grand volume de mails informatifs. Ce qui allègera encore le quotidien du conseiller/gestionnaire, qui pourra se recentrer sur la relation au sociétaire et des tâches à valeur ajoutée.</p><h3>L’Open Source dans tout ça ?</h3><p>Malgré une volonté de partage et transparence sur les outils utilisés, il est parfois difficile de faire évoluer en parallèles nos algorithmes de production et la librairie Open Source. Le facteur principal étant le manque de temps. Pour répondre aux besoins de nos utilisateurs MAIF de façon réactive, nous priorisons le déploiement en interne de Mélusine et, animer une communauté Open Source peut s’avérer chronophage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mAmfLF6k24ZKtZ2NkDxxOg.png" /></figure><p>C’est pourquoi cette année 2021, nous avons peu contribué à Mélusine Open Source. Nous restons cependant présents pour assurer le support pour répondre à vos interrogations, résoudre des bugs ou intégrer de nouvelles contributions.</p><p>Une seconde raison pour laquelle nous avons peu contribué est que, nous préparons des changements structurels de la librairie. En effet, en étendant le périmètre de Mélusine en interne, nous nous sommes rendu compte, sur certains projets, que nous utilisions du code trop spécifique et non-réutilisable.</p><p>Sur l’année 2022, nous allons entamer des travaux pour rendre notre code plus modulable et réutilisable d’un projet NLP à l’autre. Nous pourrons ensuite vous en faire profiter ! Mais il faudra d’abord que nous éprouvions cette réorganisation en production.</p><p>Cependant, nous sommes toujours enthousiastes à l’idée de recevoir de nouvelles contributions externes pour apporter de nouvelles fonctionnalités !!! Alors n’hésitez pas à nous écrire sur le <a href="https://github.com/MAIF/melusine">Github de Melusine</a> en créant une issue ou tout simplement en nous écrivant dans l’onglet « Conversation ».</p><p>Mélusine continue à évoluer. Au plaisir de vous lire !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ce5cd50802b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oss-by-maif/m%C3%A9lusine-un-retour-dexp%C3%A9rience-maif-1ce5cd50802b">Mélusine, un retour d’expérience MAIF !</a> was originally published in <a href="https://medium.com/oss-by-maif">OSS by MAIF</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>