<?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[Stories by Benoit Bln on Medium]]></title>
        <description><![CDATA[Stories by Benoit Bln on Medium]]></description>
        <link>https://medium.com/@benoitbln?source=rss-e31f8b844b0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*J0w-1-mI7CCgyvjseJ5V2Q.jpeg</url>
            <title>Stories by Benoit Bln on Medium</title>
            <link>https://medium.com/@benoitbln?source=rss-e31f8b844b0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 08:00:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@benoitbln/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Démarrez avec python en quelques minutes.]]></title>
            <link>https://benoitbln.medium.com/d%C3%A9marrez-avec-python-en-quelques-minutes-e71f9be3bb3c?source=rss-e31f8b844b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/e71f9be3bb3c</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[anaconda]]></category>
            <category><![CDATA[numpy]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <dc:creator><![CDATA[Benoit Bln]]></dc:creator>
            <pubDate>Fri, 27 Nov 2020 15:35:58 GMT</pubDate>
            <atom:updated>2020-12-01T10:52:01.879Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uDP4-xAjFSJRxPi9buWhpw.png" /></figure><p><em>Suivez notre </em><a href="http://mlacademy.substack.com/"><em>newsletter</em></a><em> pour les datascientists et data enthousiastes.</em></p><p>Suite à l&#39;article <a href="https://benoitbln.medium.com/connectez-python-et-google-sheets-pour-d%C3%A9cupler-les-performances-de-vos-feuilles-f170b00139f2">précédent</a>, j&#39;ai décidé de faire un tutoriel simple, pour démarrer l&#39;apprentissage Python de zéro en quelques minutes.</p><p>Beaucoup de possiblités existent, je me concentre ici sur une solution simple et accessible.</p><p>Les principales étapes à comprendre :</p><ul><li>Il faut installer <strong>Python</strong> sur votre ordinateur. Mais ce n&#39;est pas un &quot;logiciel&quot; en soi.</li><li>Il vous faut un endroit agréable pour ensuite écrire les scripts : c&#39;est l&#39;<strong>IDE</strong>.</li><li>Vous devez pouvoir installer facilement des <strong>librairies</strong> supplémentaires.</li></ul><h3>Préambule</h3><p>Lorsque l’on est amené à travailler sur un projet, nous allons avoir besoin d’une liste de librairies supplémentaires. L’intuition pourrait être de croire que nous allons donc avec le temps, installer de plus en plus de librairies sur notre ordinateur, pour les avoir toutes à disposition. Mais c’est faux ! Pourquoi ?</p><ul><li>Une fois qu’un programme fonctionne, et tourne en production, nous n’avons pas de raison de changer les versions des librairies qu’il utilise. En effet, une mise à jour dans une librairie peut casser une fonctionnalité.</li><li>Pour les mêmes raisons, on veut garder un <strong>environnement </strong>d’exécution aussi épuré que possible : pas de librairies superflux.</li><li>Pour assurer le plus possible de réplicabilité des résultats observés, on veut contrôler ce qui se passe dans notre environnement.</li></ul><p>Pour toutes ces raisons, on est amené à vouloir développer dans des capsules hermétiques d’environnement python :</p><ul><li>Une version de Python : 2.7, 3.5, 3.6 etc.</li><li>Une liste de librairies externes, dans des versions bien spécifiques.</li></ul><p>Nous allons donc pour cela avoir besoin d’un autre logiciel permettant de gérer cette fonctionnalité.</p><h3>Installation de Python- Anaconda</h3><p>Pour faire simple ici, je conseil d&#39;utiliser Anaconda. C&#39;est un logiciel professionel, qui permet de gérer les différents environnements, ainsi que de multiples <em>add-in</em> développement.</p><p>Il existe une version graphique, et une version en ligne de commande. Pour les plus débutants ou une utilisation très ponctuelle, je conseil la version graphique. Nous verrons plus loin un setup en ligne de commande, plus adapté pour les (futurs) développeurs.</p><p>Anaconda est disponible <a href="https://www.anaconda.com/products/individual">ici</a>, il suffit alors de choisir la version adaptée à son système d&#39;exploitation :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EH-3xf77ksOzHZZxjNF6qQ.png" /></figure><p>Une fois que c&#39;est fait, on a accès à plusieurs <em>add-in </em>pouvant être installés. Nous allons y revenir.</p><p>Nous devons tout d&#39;abord définir un premier environnement Python. Sinon le seul qui est là par défaut c&#39;est Base(root) dont l&#39;utilisation n&#39;est pas conseillé à ce stade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L2UEbgpFDp2hG1yPFmOp8A.png" /></figure><p>Il suffit donc d&#39;aller dans environnement, et d&#39;en créer un nouveau.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*uu3e97v5mB2xZaR2pHapag.png" /></figure><p>En choisissant la version de Python. On note au passage l&#39;emplacement de l&#39;environnement. Cela pourra être utile plus tard.</p><p>Maintenant, où est ce que l&#39;on écrit et exécute nos premiers scripts Python ?</p><h3>Le plus simple : Jupyter labs</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OURRa3dTeoKdIDn0hbLmKQ.png" /></figure><p>En revenant sur la page principale, et en choisissant l&#39;environnement que l&#39;on vient de créer, on a accès à d&#39;autres <em>add-ins </em>installables directement graphiquement.</p><p>On installe donc <strong>JupyterLab.</strong></p><p>Une fois fait, on le lance. On arrive dans une fenêtre web, de<strong> Python interactif. </strong>On peut y écrire et exécuter du code facilement.</p><p>Par exemple, testons le classique print(&quot;hello world&quot;) . On execute la cellule (en cliquant on on pressant <em>shift + entrée</em>), <em>hello world </em>s&#39;affiche en dessous.</p><p>On test également d&#39;importer la librairie <strong>Numpy</strong> :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bC8rL65ac9vG1XUUTKzLYQ.png" /></figure><p>Résultant en une erreur.</p><p>On peut alors directement installer les librairies dans cette fenêtre interactive :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IYg_-5iTX75Wg00W0z5-Mw.png" /></figure><h3>Pycharm</h3><p>La solution plus haut a le mérite d&#39;être rapide à mettre en place, et efficace.</p><p>Pour passer au niveau suivant, nous allons installer un très bon <strong>IDE : PyCharm</strong>.</p><p>Pour un usage personnel, il suffit d&#39;installer <a href="https://www.jetbrains.com/fr-fr/pycharm/download/">PyCharm Community</a>. Soit via le lien précédent soit directement avec Anaconda.</p><p>Il est utile d&#39;installer le JRE <strong>JetBrains</strong> à l&#39;installation.</p><p>Une fois PyCharm installé, on peut créer un nouveau projet dans un endroit choisis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E_WZxqE8smn-Cj_CyFqJGA.png" /></figure><p>Ceci permettra d&#39;avoir toute la puissance de l&#39;interpréteur python pour écrire du code:</p><ul><li>Accès à l&#39;autocomplétion.</li><li>Warnings en cas d&#39;erreurs type : variable non déclarées, typo, mauvaise signature d&#39;une fonction.</li><li>Accès rapide à la définition de n&#39;importe quelle fonction, même provenant d&#39;une libraire.</li></ul><p>Et bien d&#39;autres fonctionnalités faisant gagner un temps fou.</p><p>On peut également en cliquant sur <em>run </em>exécuter son code, si besoin en plaçant des points de debug.</p><h3>Anaconda en ligne de commande</h3><p>Dernière partie, la plus avancée. On va configurer Anaconda en ligne de commande. Je fais ce tutoriel pour ceux qui sont sous MacOS. Sous Windows, on peut utiliser le PowerShell pour obtenir des résultats similaires (il me semble).</p><h4>Installation de Brew — MacOS</h4><p>Sur Linux, on a apt , sous mac, il y a <a href="https://brew.sh/index_fr"><strong>HomeBrew</strong></a><strong>. </strong>Ce gestionnaire de paquets s&#39;installe via une ligne de commande précisée sur le lien.</p><p>Une fois brew installé, on install anaconda avec:</p><p>brew cask install anaconda</p><p>Il faut ensuite ajouter les variables globales dans votre <em>(.bashrc) .zhsrc . </em>Je recommande d&#39;utiliser ZSH au passage :</p><p>export PATH = &quot;/usr/local/anaconda3/bin:$PATH&quot; par défaut.</p><p>Normalement, la commande jupyter notebook devrait lancer un notebook comme précédemment.</p><p>Le reste de la configuration reste le même, pour PyCharm etc. Vous pouvez cependant maintenant créer, activer / désactiver vos environnements simplement par ligne de commande. Voici une <a href="https://docs.conda.io/projects/conda/en/4.6.0/_downloads/52a95608c49671267e40c689e0bc00ca/conda-cheatsheet.pdf">cheat sheet</a> Anaconda en ligne de commandes.</p><p><em>Si cet article vous a été utile, n&#39;hésitez pas à le partager et le liker. Aussi, suivez notre </em><a href="http://mlacademy.substack.com/"><em>newsletter</em></a><em> pour les datascientists.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e71f9be3bb3c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Connectez Python et Google sheets pour décupler les performances de vos feuilles !]]></title>
            <link>https://benoitbln.medium.com/connectez-python-et-google-sheets-pour-d%C3%A9cupler-les-performances-de-vos-feuilles-f170b00139f2?source=rss-e31f8b844b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f170b00139f2</guid>
            <category><![CDATA[google-sheets]]></category>
            <category><![CDATA[numpy]]></category>
            <category><![CDATA[business-intelligence]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[api]]></category>
            <dc:creator><![CDATA[Benoit Bln]]></dc:creator>
            <pubDate>Fri, 20 Nov 2020 13:23:07 GMT</pubDate>
            <atom:updated>2020-11-20T13:23:07.409Z</atom:updated>
            <content:encoded><![CDATA[<h3>Connectez Python et Google sheets pour décupler vos performances !</h3><p><em>Si ces articles vous plaisent, n&#39;hésitez pas à suivre notre </em><a href="https://mlacademy.substack.com/"><em>Newsletter</em></a><em> pour les data scientists ! Pour tout sujet concernant vos données, vous pouvez prendre rendez vous via </em><a href="https://www.predictboost.com/"><em>notre site internet</em></a><em>.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*alTBN_GPaUmOld2w.jpg" /><figcaption>Le pont Python — Google sheets</figcaption></figure><p><strong>Gsheet</strong> est désormais un incontournable business. Idéal pour faire une première analyse de données ou toute sorte de reporting en business intelligence.</p><p>Seulement les limites apparaissent rapidement:</p><ul><li>Impossible de faire des traitements complexes sur les données via les formules.</li><li>Les macros peuvent manquer, et VBA a ses limites.</li><li>On passe beaucoup de temps à faire les mêmes opérations en cas de reporting.</li><li>Impossible d&#39;exploiter des extracts de données structurés de façon erratique (autre que de simples tableaux).</li></ul><p>Tout cela est facilement faisable en <strong>Python</strong>. On peut alors automatiser beaucoup de choses, bénéficier de toute la puissance de ses librairies <strong>Pandas</strong> , <strong>Numpy</strong> ou même faire du machine learning. En bref, une fois liés, Gsheet peut devenir une database pour Python.</p><p>Nous reviendrons dans un prochain article sur comment créer une add-in Excel en python tout aussi facilement.</p><p>La question est ici : comment faire ce lien entre Python et Gsheet ?</p><p>C&#39;est simple, Google a créé une API pour cela. L&#39;idée en quelques lignes:</p><ul><li>Enregistrer notre projet auprès de Google.</li><li>Activer l&#39;API dans notre projet.</li><li>Partager la feuille cible avec notre projet.</li><li>Ecrire notre routine.</li></ul><h3>Projet et API</h3><p>On se rend pour cette première partie sur la page <a href="https://console.cloud.google.com/apis/">API</a> de Google developpers</p><p>Puis <em>créer un projet</em> sur l&#39;onglet en haut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c-xo1jOtlJvdCpyyNjQveg.png" /></figure><p>Une fois le projet créé, on arrive sur la page de gestion des APIs pour ce projet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XkUPTxLHSMhZkJHj74lesg.png" /></figure><p><em>APIs et services</em>. On clique sur <em>activer les APIs et services. </em>Si besoin on retrouve ces APIs dans la bilbiothèque sur la gauche.</p><p>Nous allons devoir activer deux APIs : <em>Google Drive</em> et <em>Google Sheets</em>. Commençons par Google Drive :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8H_Xg-SsQsgxWJ9SZZ1Hlw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z3TkaeJY3aXfqkrBmKpzWA.png" /></figure><p>On crée les identifiants : plateforme serveur web , et donnés de l&#39;application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fsa-v-75RmZI_gENjzUjFQ.png" /></figure><p>On donne un nom à ce compte, je le désigne ici propriétaire mais on peut être amené à en créer plusieurs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lV2x4sO7FPJKxoH7PNtQMg.png" /></figure><p>En faisant cela on télécharge un fichier Json contenant notre clef. Il est très important de le conserver précieusement, il contient tous les identifiants pour utiliser l&#39;API.</p><p>On repart dans la librairie pour activer l&#39;API Google Sheets, que nous avons juste besoin d&#39;activer cette fois, pas de configuration du service.</p><p>Une fois que c&#39;est fait, nous allons partager une feuille cible test.</p><p>Pour cela, il faut retourner dans la clef Json précédente et chercher le champ <em>client-mail.</em></p><p>On partage le document à cet email, tout simplement. Sur mon exemple test:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*msIo6TnUSJZK-20gn-XBag.png" /></figure><h3>Connection Pyton-Gsheet</h3><p>Maintenant que nous sommes prêt coté Google API, configurons un premier script pour communiquer depuis un notebook avec notre feuille. La <a href="https://developers.google.com/sheets/api/quickstart/python">documentation python</a> contient toute les informations détaillées sur les possibilités de l&#39;API.</p><p>Il faut auparavant installer gspread et oauth2client , les deux via pip .</p><p>Ensuite le code suivant permet d&#39;utiliser l&#39;api Gsheets via ma clef nommée MyTutorialGasheets_creds.json .</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6pJHnMyucGKFyGWIGjj1eg.png" /></figure><p>Si vous n&#39;ajoutez pas l&#39;email en partage, vous aurez une erreur<strong> 404 FORBIDDEN ACCESS </strong>à l&#39;exécution du code précédent. Sinon, vous verrez la liste des fichiers disponibles.</p><h3>Routines Python</h3><p>Voyons maintenant des exemples de calculs sur une feuille simple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9xBHdr2qod7JwMFTMs45Qw.png" /></figure><p>On considère la feuille suivante, avec des données jusqu&#39;à la ligne 363.</p><h4>Quelques exemples d&#39;utilisation de l&#39;api :</h4><p>On accède à la feuille et aux onglets de la façon suivante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KPaKGYXz476oYTQAFfZ1mg.png" /></figure><p>Voici comment accéder à une ligne ou une colonne en particulier. Un point à noter, important pour la suite : l&#39;indexing pour les accès ou les écritures sur la feuille commence à 1, et non 0 comme dans un tableau python classique.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kuP8e4k2m7iy_5UqcAt21w.png" /></figure><p>Beaucoup d&#39;informations sont accessibles concernant la feuille : nombre de lignes avec au moins une valeur dans la feuille, différents accesseurs aux cellules etc.</p><h4>Un cas d&#39;usage</h4><p>Pour nous familiariser avec l&#39;API, nous allons essayer de faire la chose suivante : ajouter une colonne <em>total_value</em> sur la colonne J.</p><p>On définit les cellules de départ et de fin, en indexing python (commençant à 0).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QvldFznvCFi1PjXSiWlS6Q.png" /></figure><p>Il faudra penser à ajouter 1 à chaque fois pour accéder aux cellules.</p><p>Les valeurs dans la feuille sont disponibles selon une double liste. Lignes en premier index, colonnes en second.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mkwffd7BIbQb8nNEksO2JA.png" /></figure><p>Ci-dessous, une méthode naive pour déterminer quelle est la dernière ligne du tableau écrite. On aurait pu compter les lignes du documents, mais j&#39;ai voulu prendre l&#39;exemple plus générique d&#39;une zone de données en général.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s713gKySUHeyNnakI4sUWA.png" /></figure><p>Note Python : l&#39;utilisation d&#39;<em>enumerate</em> est plus efficace qu&#39;un range.</p><p>Il y aura toujours un compromis entre avoir des données figées en Gsheet, ce qui donne un code simple d&#39;une part, et des données à la structure variable mais un code plus complexe en Python d&#39;autre part.</p><p>Maintenant, résolvons notre problème naïvement :</p><p>On ajoute la colonne <em>total_value </em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nUEeSHxYitxMITZkFKq0rA.png" /></figure><p>Puis les valeurs</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SaqJJHdolSXhE-iRt1Xyuw.png" /></figure><p>Première remarque, l&#39;API renvoie les données sous forme de String dans <em>vals</em>. Un casting est nécéssaire pour faire la somme.</p><p>En exécutant le code ci-dessus, on voit la feuille se mettre à jour, mais très lentement. En outre, cela s&#39;arrête à la ligne 100.</p><p>C&#39;est due aux limitations d&#39;appels API.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zPtGrQkRINOj2yvtoAR6Gg.png" /><figcaption>API usage limits</figcaption></figure><p>En outre, faire un call api est toujours une opération beaucoup plus lente que de faire le traitement sur la machine. Nous allons donc utiliser une autre méthode d’update de cellules.</p><p>En plus de la méthode utilisée plus haut, on a aussi sheet.update_acell qui permet d&#39;updater une cellule par son nom &quot;tableur&quot; : sheet.update_acell(&quot;B2&quot;, &quot;test&quot;) .</p><p>Nous allons ici utiliser sheet.update_cells qui permet d&#39;updater un range de cellules directement, en conservant le résultat final en mémoire auparavant.</p><p>On utilise cette fois Numpy pour calculer le total rapidement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NrWzgMJpHigJwCOkH9BjfQ.png" /></figure><p>Le range de cellules à considérer s&#39;initialise facilement ci-dessous:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1utQy4tNr3PxQaT1GE7fdA.png" /></figure><p>Avec un test pour vérifier la définition.</p><p>On assigne ensuite en mémoire la valeur de chaque cellule, avant de faire un update général.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bN-VT7IE-9VGgy_uM4pbGw.png" /></figure><p>Dernière note, sheet.update_cells possède un argument optionnel ValueInputOption, qui pourra changer le type final de la donnée dans la feuille gsheet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-nJfQ0XX9KztTF3m0sSaEg.png" /></figure><p>C&#39;est terminé pour ce petit exemple. Mais l&#39;API permet une utilisation beaucoup plus poussée. N&#39;hésitez pas à explorer et consulter la documentation.</p><p>Vous pouvez me contacter par mail pour obtenir le code de cet article.</p><p>N&#39;hésitez pas à partager cet article, ou à jeter un oeil aux <a href="https://medium.com/faites-d%C3%A9coller-pandas">autres</a> articles, ainsi qu&#39;à notre <a href="https://mlacademy.substack.com/">newsletter</a>.</p><p>❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f170b00139f2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Accélérez votre code python avec Cython]]></title>
            <link>https://medium.com/faites-d%C3%A9coller-pandas/acc%C3%A9l%C3%A9rez-votre-code-python-avec-cython-a10e8916ae64?source=rss-e31f8b844b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/a10e8916ae64</guid>
            <category><![CDATA[numpy]]></category>
            <category><![CDATA[cython]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Benoit Bln]]></dc:creator>
            <pubDate>Mon, 16 Nov 2020 13:19:43 GMT</pubDate>
            <atom:updated>2020-11-16T21:35:57.682Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Suivez nous dans notre </em><a href="https://mlacademy.substack.com/"><em>newsletter </em></a><em>chaque semaine !</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0IK_Vp5PDuNte60uDDPZgQ.png" /></figure><h3>Introduction</h3><p>Nous allons voir comment tirer profit de Cython pour accélérer son code.</p><p>En retournant à Cython, j’ai décidé de vous mener pas à pas dans cet article au format tutoriel. D&#39;où le nombre conséquent d&#39;étapes. J&#39;ai également noté les erreurs auxquelles je me suis confronté pour noter leurs solutions. N&#39;hésitez pas à me dire si cela vous plait !</p><p>Après avoir vu dans l<a href="https://medium.com/faites-d%C3%A9coller-pandas/5-outils-pour-faire-d%C3%A9coller-votre-code-pandas-160bd0c48d28">&#39;article précédent</a> comment accélérer un code reposant sur Pandas, nous allons nous tourner vers un autre cas d&#39;usage : accélérer une fonction.</p><p>L&#39;un des affres de Python est son Global Interpreter Lock. Un garde fou lié à l&#39;aspect interprété: un interpréteur par process. Il permet certes <em>in-fine, </em>le multi-processing (avec copie de variables), mais pas la mémoire partagée entre threads (le multi-threading). Il y a en effet risque de concurrence si deux threads tentent d&#39;accéder à la même variable en même temps.</p><p>Le multi-threading est très efficace pour effectuer beaucoup de calculs simples en parallèle, dont l&#39;ordre n&#39;importe pas. On peut toujours faire des calculs dépendant les uns des autres avec certaines routines, mais c&#39;est un niveau de difficulté supplémentaire.</p><p>Le multi-threading est plus rapide et consomme moins de mémoire que le multi-processing, ce qui le rend plus attrayant. Pour plus de détails là dessus, vous pouvez regarder <a href="https://www.openmp.org/">OpenMP</a>, la libraire référence que nous utiliserons plus loin.</p><p>Notre problème consiste à accélérer la fonction suivante:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z4Hf3OyI5Bxh_rilCu7Lvw.png" /></figure><p>Volontairement écrite très naïvement.</p><p>On en écrit trois versions alternatives :</p><ul><li>Une très pythonic : my_func_py.</li><li>Une très Numpy: my_func_np .</li><li>Enfin, une intermédiaire my_func .</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X_xVQu8Y03LtGPIfzku_EA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*937bQfX4yIx0Eez8t3QwSA.png" /></figure><p>Nous allons travailler avec un jeu de données synthétiques :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NkTRlzhdnueasfoecyvwYw.png" /></figure><h3>Premiers benchmark</h3><p>Il est important, avant de plonger dans de l&#39;optimisation pouvant être coûteuse en temps d&#39;avoir:</p><ul><li>Des benchmarks.</li><li>Essayé des méthodes rapides, permettant apriori d&#39;avoir déjà de bon résultats.</li></ul><p>Voici les temps des 4 premières méthodes présentées plus haut.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BvNA8ReliyKavHYuZReKaw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pQUpf7azpanxC84y5KUmTg.png" /></figure><p>Deux choses notables:</p><ul><li>Numpy is fast ! Pas une surprise.</li><li>Plus étonnant, les deux fonctions pythonics sont aussi lentes l&#39;une que l&#39;autre.</li></ul><h3>Numba est notre sauveur ?</h3><p>Avant de passer au cython, regardons un dernier benchmark : l&#39;utilisation de Numba, introduit dans l&#39;article précédent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VEMer_6e3WBkXqNldD4lTw.png" /></figure><p>On utilise la compilation JIT pour les deux versions les plus rapides :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RCu3RYBndnmFRFaxH5PcXQ.png" /></figure><p>Pas de gain de temps ici. Cela peut s&#39;expliquer étant donné que l&#39;on utilise ici surtout du Numpy, donc complilé, et par l&#39;essence de la compilation juste-à-temps. Mais ce n&#39;est pas le sujet ici.</p><h3>Cython</h3><p>Cython s&#39;installe avec pip de façon classique. C&#39;est un langage à part entière, compilé, qui ressemble au C et permet de faire le lien avec des routines écrites en C ou Fortran.</p><p>Pour l&#39;utiliser en notebook, il suffit de l&#39;appeler avec une magic function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XcYMBppkCcLp8LusjpymhQ.png" /></figure><p>Commençons par compiler notre code python lent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRqiBl96O5ZGxJ8j1wOMKw.png" /></figure><p>L&#39;ajout de la magic %%cython -a va compiler la cellule dans le notebook, et nous afficher une étude d&#39;efficacité. Cette étude va montrer la présence d&#39;appels à des fonctions ou objets python en surlignant en jaune. La force du trait représentant l&#39;importance de l&#39;appel.</p><p>Le code sera d&#39;autant plus rapide qu&#39;aucun appel Python ne se sera présent.</p><p>Pour cette première version, nous obtenons l&#39;analyse suivante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FHKz8WTpDN5kYI2nkIsa3g.png" /></figure><p>Très jaune donc, beaucoup d&#39;intéractions python. Les parties jaunes sont potentiellement accélérables. Voyons la vitesse de ce code compilé :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1WjNK-TKsXr0_sNTBaVUxg.png" /></figure><p>18% de speedup déjà.</p><p>Nous allons introduire une bonne accélération en limitant les intéractions pythonic :</p><ul><li>Nous allons définir les variables qui peuvent l&#39;être en Cython. n=len(data) va donc devenir une fois typée cdef int n = len(data) . <strong>Important </strong>de ne pas oublier le cdef qui permet de définir une variable Cython.</li><li>Notre tableau de résultats sera un tableau de taille variable : cdef double[:] Y</li><li>Nous utilisons la fonction exponentielle de C.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ya5UyiHsNzszac80efAiLw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7BaK40eG79H9IA882XBUCA.png" /></figure><p>Toujours beaucoup d&#39;intéractions python !</p><p>Un point sur les decorateurs et les headers cython. Nous en avons utilisés plusieurs ici:</p><p>bouncheck = False</p><p>nonecheck = False</p><p>wraparound = False</p><p>Ce sont des vérifications (overheads) que nous pouvons désactiver. <strong>Boundscheck</strong> vérifie les accès aux arrays pour éviter les <em>seg-faults</em>. <strong>Wraparound</strong> désactive l’index négatif des tableaux (pour accéder aux derniers éléments).<br>Une liste de flags disponibles, tous utilisables en décorateurs de fonction:</p><p><a href="https://github.com/cython/cython/wiki/enhancements-compilerdirectives">https://github.com/cython/cython/wiki/enhancements-compilerdirectives</a></p><p>Mais regardons la vitesse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qrcmutgx72PHKoYLCkahRw.png" /></figure><p>On est maintenant à <strong>x5 speedup.</strong> Toujours avec un effort minimal.</p><p>Regardons maintenant deux accélérations possibles :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FrRxOZEoZMq8Bn2R3TYZJw.png" /></figure><p>Ici nous allons nous attaquer à une grosse partie des intéractions Python. Elles sont dues à data en input. Nous spécifions donc son type.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tgmG9fDy-vq57JRY2jRvIA.png" /></figure><p>La différence entre les deux versions est l’utilisation ou non de Numpy, et de la variable globale len_data<br>Dans my_func_ct_3_bis, nous avons un code quasi pure Cython, sans appel python si ce n’est la définition.<br>Ceci impose de connaitre la taille des données avant d’initialiser Y, donc à la compilation. <br>A l’inverse, dans l’autre version, l’appel à une fonction numpy permet de garder un code indépendant de la taille des données.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*47mxln4nyvtc5DwMEMRYXQ.png" /></figure><p>Nous allons enfin plus vite que la version Numpy initiale, et environ <strong>113x </strong>plus vite que notre version lente initiale.</p><p>Mais l&#39;utilisation de Numpy est toujours plus rapide que la version bis, qui elle ne fonctionne que pour une taille de donnée en input fixée !</p><p>Les décorateurs comptent pour 1/8 de la vitesse de la version 3.</p><h3>Plus loin : le multi-threading</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*88IvGINv8GS7hm0zYPFgtw.png" /></figure><p>Nous gardons le même code mais essayons de paralléliser la boucle for, en utilisant prangebasé sur openMP. Cette fonction va diviser le range en chuncks, soit de taille fixe, soit dynamiquement en fonction du temps de calcul. Puis répartir les caluls sur les threads.</p><p>Le résultat final sera ensuite retourné dans notre variable de sortie. Nous devons utiliser un context nogil pour pouvoir utiliser cette fonction.</p><p>le code ci-dessus est volontairement buggé. Plusieurs choses à savoir:</p><ul><li>On ne peut pas utiliser de python dans un context nogil. Ici nous aurons donc une erreur type <strong>Coercion from Python not allowed without the GIL. </strong>Il faut penser à instancier la variable de boucle (i) également.</li><li>Une autre erreur que j&#39;ai eu dans une autre application : <strong>Constructing Python tuple not allowed without gil . </strong>Egalement due à l&#39;utilisation de fonction Python dans le context nogil : un range, ou autre.</li></ul><p>Pour continuer sur cette question d&#39;appel python / non python, nous encapsulons la routine de comparaison et d’exponentiel dans une sous routine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Id3cE5OqHZD9lCHgSE9PaQ.png" /></figure><p>L’appel à fsans <strong>GIL</strong> entrainera une erreur.<br>Mais nous pouvons définir la même version <strong>Cython</strong>. En utilisant <strong>cdef</strong> et en précisant le type de retour. Attention ! Il ne faut toutefois pas oublier de préciser le caractère <strong>NOGIL</strong> de la fonction.</p><ul><li>Les fonctions Cython ne pourront pas être utilisées en dehors de fichiers compilés.</li><li>Les fonctions Cython ne peuvent retourner un tableau.</li></ul><p>Ce qui donne la version cython suivante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9XeL5Mb1jtlLrNcGaYJOzw.png" /></figure><p>Compilée sur un core, donc serial, nous obtenons la vitesse suivante :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Il48ykabnlYk1WrPNzbQmA.png" /></figure><p>Toujours une belle accélération <strong>x135 speedup </strong>par rapport à la fonction python initiale et <strong>1.8x </strong>par rapport à la version Numpy.</p><p>Il &quot;suffit&quot; maintenant de compiler le code de façon multi-thread pour gagner de la vitesse suivant le nombre de core disponibles sur notre ordinateur.</p><p>Pour cette partie j&#39;ai du quitter le notebook. Impossible de passer les bons flags de compilation pour utiliser openMP correctement. Il faut inclure tous les headers Numpy à la compilation, et cette étape a changé récemment.</p><p>Pour compiler du code Cython, rien de plus simple. Il suffit de créer un fichier .pyx et de préparer le fichier setup.py ci-dessous:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lW9ghW6ebpCwKINiW3Gqsg.png" /></figure><p>Il précise le fichier à compiler, ici functions_cy.pyx , le package résultant functions_cytho , et surtout, tous les arguments de compilation. Incluant ceux de Numpy.</p><p>Sous MacOS il est recommandé d&#39;utiliser lomp pour Homebrew libomp, quand on peut utiliser fopenmp sous Linux en extra_link_args .</p><p>Ensuite executer : python setup.py build_ext — inplace</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4JpMVJ95Q_Opt3Pg8-xm2w.png" /></figure><p>Dans la version ci-dessus, nous avons un scheduler static, qui découpe nos donnée en chunks de taille égale (vu le problème, le temps de calcul doit être équivalent), en répartissant sur 4 threads.</p><p>L&#39;utilisation sous MacOs d&#39;OpenMP peut être compliquée. Nous avons testé sous différents environnements, pour obtenir des speedup encore proches du nombre de coeurs disponibles : légèrement inférieurs à <strong>x2</strong> pour deux coeurs et à <strong>x4</strong> pour 4 coeurs.</p><p>Nous arrivons donc à la fin de cet article, où nous avons un speedup pouvant être rapidement de <strong>x10 </strong>et plus sur une machine récente par rapport à numpy.</p><p>Il y a beaucoup à dire coté compilation. C&#39;est un sujet d&#39;étude à part entière, le <strong>High-performance-computing</strong>. Le compilateur choisi, on le voit avec Numba, joue un role clef. L&#39;utilisation de compilateurs optimisés comme Intel-mkl , ou tout simplement la distribution Python d&#39;Intel peut accélérer le code énormément.</p><p><em>Si ces sujets vous intéressent, n&#39;hésitez pas à nous suivre dans notre </em><a href="https://mlacademy.substack.com/"><em>news-letter </em></a><em>chaque semaine, à donner votre avis et à partager l&#39;article ❤.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a10e8916ae64" width="1" height="1" alt=""><hr><p><a href="https://medium.com/faites-d%C3%A9coller-pandas/acc%C3%A9l%C3%A9rez-votre-code-python-avec-cython-a10e8916ae64">Accélérez votre code python avec Cython</a> was originally published in <a href="https://medium.com/faites-d%C3%A9coller-pandas">Accélérer et faites scaler votre code python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[5 outils pour faire décoller votre code Pandas]]></title>
            <link>https://medium.com/faites-d%C3%A9coller-pandas/5-outils-pour-faire-d%C3%A9coller-votre-code-pandas-160bd0c48d28?source=rss-e31f8b844b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/160bd0c48d28</guid>
            <category><![CDATA[dask]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[profiling]]></category>
            <category><![CDATA[numba]]></category>
            <dc:creator><![CDATA[Benoit Bln]]></dc:creator>
            <pubDate>Fri, 06 Nov 2020 15:00:18 GMT</pubDate>
            <atom:updated>2020-11-09T09:23:18.353Z</atom:updated>
            <content:encoded><![CDATA[<p>5 outils pour profiler et accélérer votre code python. Pandas, Numba, Dask, Swifter et PandasParallel !</p><p><em>Si ces sujets vous intéressent suivez nous dans notre </em><a href="https://mlacademy.substack.com/"><em>newsletter</em></a><em> !</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*jHWOlqHk-BR8oRxE.jpg" /></figure><p>Qui n&#39;a pas été confronté au cas classique d&#39;un code python mettant plusieurs minutes à s&#39;exécuter, pour enfin accéder au bug suivant. On est alors tenté de passer du temps à optimiser notre code.</p><p>On se pose alors deux questions :</p><ul><li>Comment faire ?</li><li>Combien de temps y consacrer ?</li></ul><h4>Introduction</h4><p>Pour commencer, nous considérons un problème assez classique: appliquer une méthode à différentes observations.<br>Plus précisément, dans le cas de l’utilisation de <strong>Pandas</strong>.</p><p>Un exemple simple de ce cas, est de devoir appliquer une fonction donnée à <strong>chacun de nos utilisateurs</strong>. Nous aurions donc en Dataframe une ligne par utilisateur, sur lesquelles nous voulons appliquer notre fonction, compte tenu d’un nombre de features en colonne fixe.</p><p><strong>Un autre exemple classique</strong>: la série temporelle. Une très longue série, et à chaque pas de temps, nous voulons appliquer un certain modèle.</p><p>Notre dataset sera constitué ici d&#39;1,000,000 de lignes et de 20 features, float64 entre 0 et 100.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V_aFwXl5EckXjq7dp-emlQ.png" /></figure><p>Nous allons ici considérer que la fonction à appliquer à chaque ligne est une <strong>simple régression linéaire </strong>sur les features qui retourne le <strong>coefficient directeur</strong>.</p><h4>Le profiling</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uxkEG6eJiozKQgCC1YROAw.png" /></figure><p>Nous implémentons les moindres carrés en utilisant volontairement deux méthodes <em>apriori</em> similaires : celle de <strong>Sklearn </strong>et celle de <strong>Numpy.</strong></p><p>Etudions leurs performances. Nous utilisons la magic function <em>timeit.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qPShMSyJ6TnIbsOouQUJpQ.png" /></figure><p>Une différence de performance importante qui nous permet de faire une aparté sur le concept d&#39;overhead.</p><p>C’est un concept important puisque python a tendance à beaucoup l’utiliser.<br>L’overhead consiste pour faire simple en une suite d’opérations, effectuées avant l’opération qui nous intéresse vraiment. Exemple: <strong>vérifier la non-nullité de deux facteurs avant une division.</strong><br>Important aussi à avoir en tête, dans le cadre d’une accélération de code, il y a toujours un arbitrage à faire entre robustesse aux différentes utilisations, et rapidité. Plus il y aura d’overhead, plus le code sera potentiellement robuste, mais sûrement moins rapide.</p><p>Comment expliquer ici la différence de vitesse ? Par l’intuition déjà, <strong>Numpy</strong> est sous-jacent à de très nombreuses librairies mathématiques, dont S<strong>klearn</strong>. Intuitivement, il doit y avoir un appel à cette librairie d’algèbre, et de l’overhead.<br>Mais nous pouvons le vérifier, et trouver le goulot d’étranglement de notre code, avec le très pratique <strong>line_profiler</strong>.<br>Ce module permet d’avoir une inspection détaillée de son code, pour trouver ici les points bloquant de la méthode basée sur <strong>Sklearn.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IvrpEEx6-3B7O4s_lGXt9Q.png" /></figure><p>Une fois initialisé nous pouvons afficher les performances observées.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oo3HLs4SXHcOAEwNyxZciQ.png" /></figure><p>On retrouve bien,<strong> ligne 547</strong> l’appel à la librairie <strong>Numpy</strong>. Mais également divers autres opérations, et un appel supplémentaire <strong>ligne 505</strong>, de validation des datas. C’est typiquement le genre d’overhead qui ralentit le code, mais permet aussi de gagner beaucoup dans temps en général.<br>Apriori, cette fonction de <strong>Sklearn</strong> est plutôt utilisée sur un très gros dataset, une seule fois. Le compromis vitesse / sécurité est donc bien justifié.<br>Ici nous appliquons la fonction à un tout petit dataset, beaucoup de fois. Nous pouvons considérer avoir vérifié nos données en amont pour seulement utiliser <strong>Numpy</strong> ici.</p><h4>Résolution de tout le problème, de naif à avancé.</h4><p>On commence par la version ultra naïve. Celle qu’utiliserait probablement quelqu’un ne codant qu’en langage typé classique. On boucle sur le dataframe, on crée une variable intermédiaire.<br>Nous reviendrons sur les bénéfices de cette approche dans un article sur l’utilisation de <strong>Cython</strong>.<br>Cependant ici, ce n’est pas pythonic du tout, mais ça nous donne un premier benchmark de vitesse d’exécution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eQDdRtMrpFcEZCppf2WuRQ.png" /></figure><p>Une version un peu plus pythonic:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M8NsrpXLRRqJkqvDUr7R1g.png" /></figure><p>Un bon gain de temps déjà, en ne faisant qu&#39;utiliser la syntaxe <strong>Python</strong> adaptée, et l&#39;itérateur <strong>Pandas</strong> sur les lignes.</p><p>Maintenant avec une syntaxe <strong>Pandas </strong>(fonction apply):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6s6HWLhTtYuaA9wvZaDIig.png" /></figure><p>On est déjà <strong>2.8x </strong>plus rapides, en n&#39;ayant fait aucuns efforts ou presque.</p><p>Pour aller plus vite, on va utiliser le plus possible <strong>Numpy</strong> plutôt que <strong>Pandas.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KVL771lgivSzyDt8RSLgeg.png" /></figure><p>On définit donc la même méthode, mais prenant en entrée non plus une ligne de dataframe, mais un array numpy. On n&#39;accède plus à <em>row.value.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fpy7XClGZt5k7g3UnZYMGQ.png" /></figure><p>On peut alors utiliser l&#39;option raw=True afin de passer les arrays <strong>Numpy, </strong>aboutissant à une accélération quasi gratuite.</p><p>Nous allons maintenant voir une autre librairie d&#39;accélération : <a href="https://github.com/jmcarpenter2/swifter"><strong>Swifter</strong></a><strong>, </strong>qui fera la transition vers <a href="https://github.com/dask/dask"><strong>Dask</strong></a><strong>. </strong>Swifter<strong> </strong>est un wrapper par dessus Dask. Une série de méthodes permet de faire un estimé du temps nécessaire pour effectuer la méthode sur quelques lignes. Il en déduit ensuite si il est intéressant de paralléliser les opérations via Dask.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GmoKq-u5UTXJhLlTgD-7Vw.png" /></figure><p>Nous avons effectué l&#39;opération sur un Macbook pro dual core. On attendrait donc un speed up <strong>x2</strong> mais les différents overheads expliquent probablement la différence observée.</p><p>Autre librairie très similaire : <a href="https://github.com/nalepae/pandarallel"><strong>Pandarallel</strong></a>. Cette librairie s&#39;utilise également en wrapper par dessus Pandas, permettant l&#39;utilisation des routines multiprocessing de <strong>Python, </strong>fournissant entre autre un apply parallel.</p><p>On l&#39;initialise simplement :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SnCkmcJE7ofHZBNOiuG_iQ.png" /></figure><p>Le code s&#39;adapte ensuite facilement :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cD1pXbt0pZvTnmLFOAB_6Q.png" /></figure><p>On obtient cette fois un speed up bien plus proche du <strong>x2 </strong>attendu.</p><p>Regardons <strong>Dask </strong>plus en détails:</p><p>Dask nécessite déjà un plus gros investissement. Il faut l&#39;initialiser également :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IftIVwLIKE7E4En4offPTw.png" /></figure><p>En convertissant le dataframe Pandas au format Dask:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j4wQZq8tHoWx6jWNlP3q_g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*muQf74wZXiINcU81Sqlq9w.png" /></figure><p>On remarque l&#39;utilisation d&#39;une méthode ols_numpy_raw_import . C&#39;est une erreur que j&#39;ai eu. Impossible d&#39;utiliser Dask sur une fonction définie dans le notebook, pour des raison de sérialization. J&#39;y reviendrais dans un prochain article, ce genre de problème est courant. La méthode est donc la même, mais définie dans un fichier annexe et importée.</p><p>On utilise ici deux méthodes différentes de Dask pour effectuer la même tache. La seconde est plus proche du fonctionnement sous-jacent de Dask.</p><p>Il faut également prendre en compte pour Dask l&#39;importance du nombre de partitions, qui doit être choisi en fonction du nombre de process disponibles.</p><p>Enfin, Dask est en lui même bien plus puissant qu&#39;une simple parallélisation de apply. Il permet de gérer tout un graph de calcul, en évitant les bottlenecks et parallélisant au maximum de façon similaire à Spark.</p><p>Imaginons que nous ayons une une fonction renvoyant un scalaire et prenant les colonnes entières en entrée. Alors il y aurait une différence. La seconde méthode renverrait autant de scalaires que de partitions. La première, un seul scalaire.</p><p>In-fine, Dask est légèrement plus lent que Pandarallel sur cet exemple.</p><h4>Encore plus vite: <a href="https://numba.pydata.org/numba-doc/latest/user/5minguide.html">Numba</a></h4><p>Il existe un autre moyen simple d&#39;accélérer votre routine : changer la méthode de compilation du code. Sans rentrer dans le détails, le code sera compilé à la volée, avec ajout de directives de compilation le rendant beaucoup plus rapide.</p><p>Très simple à générer, il suffit de décorer la fonction python initiale :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*SzujagHrEc_RKhQmscrt4A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dY7jLJSaHZ_RLvWLfgIxLA.png" /></figure><p>On initialise la fonction sur une ligne pour faire une première compilation (qui prend légèrement plus de temps). Le résultat est sans appel: <strong>x18 </strong>par rapport à notre méthode naive initiale, et <strong>x5 </strong>par rapport à un apply pandas optimisé.</p><p>Il ne reste plus qu&#39;à grouper nos deux meilleures méthodes: pandas parallel et Numba</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p-y8jIITg9hB5GQxMJ_2BA.png" /></figure><p>On atteint finalement 5sec d&#39;éxecution. <strong>x10 </strong>de speedup par rapport à un apply optimisé, pour un décorateur et une fonction, sur seulement deux cores.</p><h4>Extra: la vectorisation.</h4><p>Une dernière technique, la plus simple, mais qui ne fonctionne pas dans notre cas. A ne surtout pas négliger. Pandas est optimisé pour les calculs de fonctions vectorielles: qui s&#39;appliquent directement sur les colonnes d&#39;un dataframe, à l&#39;image du calcul matriciel en Numpy.</p><p>Nous définissons donc une nouvelle fonction, applicable à deux scalaires:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*mZ7G-2UP3s08SOkoOIH0hg.png" /></figure><p>et un dataframe de test:</p><pre>data_end = pd.DataFrame(np.random.randint(0, 10, (100000, 2)))</pre><p>Regardons le temps d&#39;éxecution de la fonction sur notre dataset:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FYH5nDTf2Lf2S1PkxT9w_g.png" /></figure><p>Mais notre fonction peut indifféremment être utilisée comme agissant sur les colonnes du dataframe, le produit * étant aussi le produit terme à terme pour un dataframe.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lb6qZQvS-IjikEgfZ-bkqw.png" /></figure><p>On vérifie au passage que les résultats sont les même.<strong>x5000 </strong>speedup sans rien faire.</p><p>Il faut parfois faire quelques efforts supplémentaires pour vectoriser une fonction, mais c&#39;est souvent très rentable.</p><h4>Conclusion</h4><p>Nous avons vues différentes méthodes pour accélérer un apply Pandas.</p><p>Ce qu&#39;il faut retenir, et qui répond en parti à la question du temps à y consacrer:</p><ul><li>Certaines méthodes comme Numba ne coûte littéralement rien.</li><li>D&#39;autres comme Swifter ou Pandas Parallel demandent un peu plus d&#39;efforts.</li><li>Enfin, l&#39;artillerie lourde comme Dask est un investissement plus conséquent, mais plus adaptable à des situations très complexes.</li></ul><p>Le temps à y consacrer doit être proportionnel à l&#39;importance du projet, et surtout au nombre d&#39;itérations envisagées. Car c&#39;est bien ce temps-là que l&#39;on veut réduire, pour être le plus agile possible.</p><p><em>L’idée de cet article m’est venu en écoutant l’excellent </em><a href="https://ianozsvald.com/"><em>Ian Ozwald </em></a><em>et sa </em><a href="https://www.youtube.com/watch?v=I1xyjc-JgGM&amp;t=1254s"><em>conférence</em></a><em> sur l’accélération de code Pandas. Je n&#39;ai pas réussi à répliquer ses performances cependant, mais tout dépend de beaucoup de paramètres de configuration.</em></p><p><em>Si le sujet vous a plu n&#39;hésitez pas m&#39;envoyer un mail à benoit@predictboost.com, je vous enverrai le notebook avec tout le code.</em></p><p><em>Si ces sujets vous intéressent suivez nous dans notre </em><a href="https://mlacademy.substack.com/"><em>newsletter</em></a><em> !</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=160bd0c48d28" width="1" height="1" alt=""><hr><p><a href="https://medium.com/faites-d%C3%A9coller-pandas/5-outils-pour-faire-d%C3%A9coller-votre-code-pandas-160bd0c48d28">5 outils pour faire décoller votre code Pandas</a> was originally published in <a href="https://medium.com/faites-d%C3%A9coller-pandas">Accélérer et faites scaler votre code python</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>