IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Polars, la bibliothèque de frameworks de données pour Python, évolue de la Version 0.19.0 à 0.20


Sujet :

Python

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Rédacteur technique
    Inscrit en
    May 2019
    Messages
    1 802
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : May 2019
    Messages : 1 802
    Points : 35 767
    Points
    35 767
    Par défaut Polars, la bibliothèque de frameworks de données pour Python, évolue de la Version 0.19.0 à 0.20
    Polars, la bibliothèque de frameworks de données pour Python, évolue de la version 0.19.0 à 0.20,
    elle utilise Rust pour le moteur de requête et apporte le type de données Enum

    Polars est une bibliothèque de frameworks de données conçue pour offrir des performances optimales dans le traitement des données. Son moteur de requête multithread, écrit en Rust, favorise un parallélisme efficace, tandis que son traitement vectoriel et en colonnes assure des algorithmes cohérents avec le cache et des performances élevées sur les processeurs modernes. La conception intuitive de ses expressions facilite l'écriture de code lisible et performant, rendant l'utilisation de Polars accessible aux utilisateurs familiarisés avec la manipulation de données.

    Polars présente des caractéristiques attrayantes, telles que sa conception axée sur la performance, son traitement multithread et sa facilité d'utilisation. Le choix d'utiliser Rust pour le moteur de requête contribue à la robustesse du système. La comparaison avec d'autres solutions sur le benchmark TPCH met en avant ses avantages significatifs en termes de rapidité d'exécution, surpassant même des bibliothèques populaires comme pandas. Cependant, il serait intéressant de surveiller l'évolution de Polars au fil du temps, notamment en termes de croissance de la communauté et d'ajout de nouvelles fonctionnalités.

    Nom : Polars111.jpg
Affichages : 40908
Taille : 3,2 Ko

    Toutefois, une évaluation plus poussée pourrait mettre en lumière certaines lacunes potentielles. Tout d'abord, bien que Polars se targue de sa rapidité sur le benchmark TPCH, il est important de noter que les performances peuvent varier en fonction du contexte d'utilisation réel et des types de données spécifiques. Les résultats d'un benchmark isolé ne sont pas toujours représentatifs de toutes les situations.

    De plus, bien que l'accent soit mis sur la facilité d'utilisation, la courbe d'apprentissage peut donc être plus abrupte pour ceux qui ne sont pas déjà familiarisés avec la manipulation de données. Un autre aspect à considérer est la taille de la communauté des développeurs. Une communauté plus restreinte peut entraîner des retards dans les mises à jour, des problèmes de support technique et un manque de diversité dans le développement de nouvelles fonctionnalités. Il serait donc crucial de suivre l'évolution de la communauté autour de Polars pour garantir une croissance soutenue.

    Les utilisateurs potentiels devraient évaluer attentivement leurs besoins spécifiques et surveiller de près l'évolution continue de Polars avant de choisir cette bibliothèque pour des applications critiques.

    Polars a été comparé à plusieurs autres solutions sur l'échelle de référence TPCH facteur 10. Les benchmarks ont été exécutés sur un gcp n2-highmem-16. Il s'agit encore d'un travail en cours et d'autres requêtes/bibliothèques seront bientôt disponibles. Le benchmark TPCH initial est conçu pour les bases de données SQL et ne permet aucune modification du SQL associé à cette question spécifique. Les interfaces SQL sont évaluées par rapport aux interfaces DataFrame, nécessitant ainsi des ajustements mineurs des règles initiales. Il est nécessaire de traduire les requêtes SQL de manière sémantique en requêtes idiomatiques adaptées à l'outil hôte. Pour accomplir cette tâche, l'équipe de Polars a observé et suivi scrupuleusement les règles énoncées ci-dessous :

    • il n'est pas permis d'insérer de nouvelles opérations, par exemple pas d'élagage d'une table avant une jointure ;
    • chaque solution doit fournir une requête par question, indépendamment de la source de données et solution doit appeler sa propre API ;
    • elle est autorisée à déclarer le type de jointures, car cela correspond au raisonnement sémantique des API DataFrame ;
    • une solution doit choisir un seul moteur/mode pour toutes les requêtes. Il est permis de proposer différentes solutions du même fournisseur, par exemple (sparks-sql, pyspark, polars-sql, polars-default, polars-streaming). Cependant, ces solutions doivent exécuter toutes les requêtes, en montrant leurs forces et leurs faiblesses, pas de "cherry picking".

    Nom : polars.jpg
Affichages : 1459
Taille : 78,1 Ko

    Type de données Enum

    La version 0.20.0 introduit le type de données Enum, une nouvelle façon de traiter les données catégorielles. Il garantit un encodage cohérent entre les colonnes ou les ensembles de données, ce qui rend les opérations telles que l'ajout ou la fusion plus efficaces sans nécessiter de réencodage ou de recherches supplémentaires dans le cache.

    Ce type de données est différent du type Categorical, qui peut entraîner des coûts de performance dus à l'inférence des catégories. Toutefois, il est important de noter que le type Enum ne permet d'utiliser que des catégories prédéfinies et que toute valeur non spécifiée entraînera des erreurs. Enum est une option fiable pour les ensembles de données dont les valeurs catégorielles sont connues, ce qui améliore les performances lors de la manipulation des données. Exemples d'utilisation du nouveau type Enum :

    Example 1

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    >>> enum_dtype = pl.Enum(["Polar", "Brown", "Grizzly"])
    >>> pl.Series(["Polar", "Grizzly", "Teddy"], dtype=enum_dtype)
    ComputeError: value 'Teddy' is not present in Enum: LargeUtf8Array[Polar, Brown, Grizzly]
    Example 2

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    >>> enum_series = pl.Series(["Polar", "Grizzly", "Brown", "Brown", "Polar"], dtype=enum_dtype)
    >>> cat_series = pl.Series(["Teddy", "Brown", "Brown", "Polar", "Polar"])
    >>> enum_series.append(cat2_series)
    SchemaError: cannot extend/append Categorical(Some(enum), Physical) with Utf8
    Polar Plugins

    Les plugins d'expression ont fait leur entrée. Ils vous permettent de compiler une UDF (fonction définie par l'utilisateur) en Rust et de l'enregistrer en tant qu'expression dans le binaire principal de Python Polars. Le binaire principal de Python Polars appellera la fonction via FFI. Cela signifie que vous aurez les performances de Rust et tout le parallélisme du moteur Polars car il n'y a pas de verrouillage GIL.

    Un autre avantage est que vous pouvez utiliser toutes les caisses disponibles dans le paysage Rust pour accélérer votre logique d'entreprise.

    Accélérations algorithmiques

    Polars apporte de nombreuses améliorations liées aux performances. Voici, ci-dessous, le script pour exécuter le benchmark :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    import numpy as np
    	import pandas as pd
    	import polars as pl
    	import matplotlib.pyplot as plt
     
     
    	def plot_grouped_benchmark_results(results: dict):
    	    libraries = [
    	        f"Polars {pl.__version__}",
    	        f"Pandas {pd.__version__}",
    	        f"NumPy {np.__version__}",
    	    ]
    	    operations = ["Corr", "Cov"]
     
     
    	    data = {
    	        op: [results[f"{op} with {lib.split()[0]}"] for lib in libraries]
    	        for op in operations
    	    }
     
     
    	    x = range(len(operations))
     
     
    	    x = range(len(operations))
     
     
    	    custom_colors = ['#0075FF', '#73bfb8', '#26413c']
     
     
    	    plt.figure(figsize=(10, 6))
     
     
    	    for i, library in enumerate(libraries):
    	        plt.bar(
    	            [pos + i * 0.2 for pos in x],
    	            [data[operation][i] for operation in operations],
    	            width=0.15,
    	            label=library,
    	            color=custom_colors[i]
    	        )
     
     
    	    plt.xlabel("Operation")
    	    plt.ylabel("Average Time (s)")
     
     
    	    plt.title("Benchmarking Results Grouped by Operation")
     
     
    	    ax = plt.gca()
    	    ax.spines['right'].set_visible(False)
    	    ax.spines['top'].set_visible(False)
     
     
    	    plt.xticks([pos + 0.2 for pos in x], operations)
    	    plt.legend()
    	    plt.savefig('algorithmic_speedups_results.png')
    	    plt.show()
     
     
    	plot_grouped_benchmark_results(benchmark_results)
    Polars vise à créer une API cohérente, expressive et lisible. Cependant, cela peut être en contradiction avec l'écriture d'un code interactif rapide - par exemple, lors de l'exploration de données dans un carnet de notes.

    L'équipe de développement de Polars a récemment annoncé la transition de la version 0.19.0 à la version 0.20, introduisant le type de données Enum. Bien que Polars soit vanté comme une bibliothèque de frameworks de données offrant des performances optimales, plusieurs points critiques méritent d'être examinés de plus près.

    Entre promesses et réalités : un regard prudent sur Polars

    Bien que le moteur de requête multithread de Polars, rédigé en Rust, soit loué pour son parallélisme efficace et que son traitement vectoriel en colonnes garantisse des performances élevées, il est important de souligner que les résultats obtenus sur le benchmark TPCH ne sont pas nécessairement représentatifs de toutes les situations réelles. Les performances peuvent varier en fonction du contexte d'utilisation et des types de données spécifiques, remettant en question la fiabilité de l'évaluation basée sur un benchmark isolé.


    Malgré la conception intuitive de Polars qui facilite l'écriture de code lisible et performant, la courbe d'apprentissage peut s'avérer abrupte pour les utilisateurs non familiers avec la manipulation de données. Cette caractéristique pourrait poser des obstacles à l'adoption de Polars pour ceux cherchant une solution conviviale et rapide pour l'exploration de données dans un carnet de notes, où l'aspect interactif est essentiel.

    Un autre point de préoccupation réside dans la taille de la communauté des développeurs autour de Polars. Une communauté plus limitée pourrait entraîner des retards dans les mises à jour, des problèmes de support technique et un manque de diversité dans le développement de nouvelles fonctionnalités. La croissance continue de la communauté devrait donc être surveillée attentivement pour assurer la pérennité du projet.

    Source : Polars

    Et vous ?

    Quel est votre avis sur le sujet ?

    Comment l'utilisation de Rust pour le moteur de requête impacte-t-elle la stabilité et la performance globale de Polars par rapport à d'autres bibliothèques concurrentes ?

    Selon vous, y a-t-il des limitations ou des cas d'utilisation spécifiques où l'utilisation du type de données Enum dans Polars pourrait poser des problèmes ou nécessiter des adaptations particulières ?

    Voir aussi :

    Keras 3, une API open-source d'apprentissage profond, fournit une interface Python facile pour les réseaux neuronaux artificiels et peut fonctionner au-dessus de JAX, TensorFlow ou PyTorch

    PySimpleGUI : un paquetage Python qui permet aux programmeurs Python de tous niveaux de créer des interfaces graphiques et de transformer Qt, tkinter, WxPython et Remi en une interface plus simple

    Python 3.13 ajoute un compilateur JIT qui pourrait améliorer les performances du langage d'environ 9 %, mais l'annonce suscite des réactions mitigées
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Membre émérite
    Profil pro
    retraité
    Inscrit en
    December 2010
    Messages
    800
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : retraité

    Informations forums :
    Inscription : December 2010
    Messages : 800
    Points : 2 279
    Points
    2 279
    Par défaut
    J'utilise pandas pour lire des fichiers excel/opendocument. Cela marche bien, avec polars j'ai des erreurs de conversion de format et quand je supprime les colonnes et qu'il n'y a plus ces erreurs j'ai des erreurs de duplication de noms de colonnes avec la fonction read_ods.

    Bref je reste encore sous pandas

Discussions similaires

  1. Réponses: 15
    Dernier message: 05/08/2016, 18h25
  2. Le framework open source Django sort en version 1.7
    Par Hinault Romaric dans le forum Django
    Réponses: 9
    Dernier message: 13/09/2014, 12h31
  3. Modifications framework
    Par rgarnier dans le forum XMLRAD
    Réponses: 5
    Dernier message: 18/06/2003, 19h08
  4. TreeView -> ajouter un child à un noeud donné
    Par fake dans le forum Composants VCL
    Réponses: 6
    Dernier message: 26/03/2003, 18h14
  5. connexion base de donné
    Par saidi dans le forum MFC
    Réponses: 3
    Dernier message: 07/08/2002, 23h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo