Dataframe dans Apache PySpark : Tutoriel complet [avec exemples]

Aujourd'hui, nous allons découvrir le DataFrame dans Apache PySpark . Pyspark est l'un des meilleurs outils de science des données en 2020. Il est nommé colonnes d'une collection distribuée de lignes dans Apache Spark. Il est très similaire aux tableaux ou aux colonnes des feuilles Excel et également similaire au tableau de la base de données relationnelle. PySpark DataFrame a également des caractéristiques similaires de RDD, qui sont :

Distribué : la nature de DataFrame et de RDD est à la fois distribuée

Évaluations paresseuses : l'exécution de la tâche n'est pas effectuée si l'action n'est pas effectuée

Nature de l'immuable : une autre caractéristique similaire de RDD / DataFrame est qu'il ne peut pas être modifié une fois créé. Mais on peut appliquer la transformation pour transformer le RDD/DataFrame.

Avantage des DataFrames

1. Cela prend en charge de nombreux langages différents, tels que Java, Scala, R, Python, ce qui est utile en termes de prise en charge de l'API. La prise en charge de plusieurs langages par l'API permet de travailler avec de nombreux langages de programmation.

2. Un large éventail de sources de données et de formats sont pris en charge par DataFrame, ce qui aide beaucoup à utiliser une source de données différente et leur format de manière pratique.

3. L'une des meilleures parties de DataFrame est qu'il peut même gérer des pétaoctets de données, ce qui est une capacité remarquable à gérer des données aussi massives.

4. Apache Spark comprend rapidement le schéma de DataFrame avec l'observation dans Spark DataFrame. Sous des colonnes nommées, l'observation du Spark DataFrame est organisée. De cette façon, le plan d'exécution des requêtes est optimisé.

5. Un volume massif de données semi-structurées et structurées peut être traité rapidement car il est conçu pour le faire DataFrames.

Configuration d'Apache Spark

Apache Spark doit être configuré sur la machine avant de pouvoir être utilisé pour les opérations DataFrame. Les données peuvent être exploitées avec le support de DataFrame car il prend en charge diverses opérations DataFrame. Ici, nous allons discuter de certaines opérations courantes de DataFrame.

La création de SparkContext est la première étape de la programmation d'Apache. Pour l'exécution d'opérations dans un cluster, il existe une exigence de SparkContext. Comment accéder à un cluster est indiqué par SparkContext. Il montre également le Spark sur l'emplacement pour obtenir un cluster.

Lire : Cadres d'apprentissage en profondeur

Ensuite, la connexion Apache Cluster est établie. Sa création est déjà faite si l'on utilise Spark Shell. L'autre méthode, le paramètre de configuration, peut être fournie, initialisée et importée pour la création du SparkContext.

On peut utiliser ce code pour la création :

de pyspark importer SparkContext

sc = SparkContext()

Création de DataFrame à partir d'un fichier CSV

Une nouvelle bibliothèque doit être spécifiée dans le shell de python afin que le fichier CSV puisse être lu. Pour ce faire, la première étape consiste à télécharger la dernière version du package Spark-CSV et à effectuer l'extraction du package dans le répertoire personnel de Spark. Après cela, nous ouvrirons le shell de PySpark et le package doit être inclus.

$ ./bin/pyspark –packages com.databricks:spark-csv_2.10:1.3.0

Maintenant, le DataFrame sera créé après la lecture des données à partir du fichier CSV.

train = sqlContext.load(source=”com.databricks.spark.csv”, chemin = 'PATH/train.csv', header = True,inferSchema = True)

test = sqlContext.load(source=”com.databricks.spark.csv”, chemin = 'PATH/test-comb.csv', header = True,inferSchema = True)

Les fichiers CSV de test et les fichiers CSV de formation se trouvent dans l'emplacement du dossier appelé PATH. Si l'en-tête est présent dans le fichier CSV, il s'affichera comme True. Pour connaître le type de données dans chaque colonne de la trame de données, nous utiliserons l'option inferSchema = True. En utilisant l'option inferSchema = True, la détection du type de données de chaque colonne de la trame de données sera détectée automatiquement par le contexte SQL. Toutes les colonnes seront lues comme une chaîne si nous ne définissons pas inferSchema sur true.

Lire : Bibliothèques Python pour l'apprentissage automatique

Manipulation de DataFrame

Maintenant, ici, nous allons voir comment manipuler le Data Frame :

• Connaître le type de données des colonnes

printSchema sera utilisé pour voir le type de colonne et son type de données. Maintenant, le schéma sera imprimé sous forme d'arbre en appliquant le printSchema().

train.printSchema()

Sortir:

racine

|– User_ID : entier (nul = vrai)

|– Product_ID : chaîne (nullable = true)

|– Sexe : chaîne (nullable = true)

|– Âge : chaîne (nullable = true)

|– Profession : entier (nullable = vrai)

|– City_Category : chaîne (nullable = true)

|– Stay_In_Current_City_Years : chaîne (nullable = true)

|– Marital_Status : entier (nullable = true)

|– Product_Category_1 : entier (nullable = true)

|– Product_Category_2 : entier (nullable = true)

|– Product_Category_3 : entier (nullable = true)

|– Achat : entier (nullable = true)

Après la lecture du fichier de csv, nous pouvons voir que nous avons obtenu avec précision le type de données ou le schéma de chaque colonne dans la trame de données.

• Affichage de la première observation n

Pour voir la première n observation, on peut utiliser l'opération de tête. L'opération principale de Pandas est la même que celle de l'opération principale de PySpark.

tête de train(5)

Sortir:

[Row(User_ID=1000001, Product_ID=u'P00069042′, Gender=u'F', Age=u'0-17′, Occupation=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status= 0, Product_Category_1=3, Product_Category_2=Aucun, Product_Category_3=Aucun, Achat=8370),

Ligne(User_ID=1000001, Product_ID=u'P00248942′, Sexe=u'F', Age=u'0-17′, Occupation=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Product_Category_1=1, Product_Category_2=6, Product_Category_3=14, Purchase=15200),

Ligne(User_ID=1000001, Product_ID=u'P00087842′, Sexe=u'F', Age=u'0-17′, Occupation=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Product_Category_1=12, Product_Category_2=Aucun, Product_Category_3=Aucun, Achat=1422),

Ligne(User_ID=1000001, Product_ID=u'P00085442′, Sexe=u'F', Age=u'0-17′, Occupation=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Product_Category_1=12, Product_Category_2=14, Product_Category_3=Aucun, Achat=1057),

Ligne(User_ID=1000002, Product_ID=u'P00285442′, Sexe=u'M', Age=u'55+', Occupation=16, City_Category=u'C', Stay_In_Current_City_Years=u'4+', Marital_Status=0 , Product_Category_1=8, Product_Category_2=Aucun, Product_Category_3=Aucun, Achat=7969)]

Nous allons maintenant utiliser l'opération d'affichage pour mieux voir le résultat car les résultats seront au format de ligne. Nous pouvons également tronquer le résultat en utilisant l'argument truncate = True.

train.show(2,truncate= Vrai)

Sortir:

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|ID_utilisateur|ID_produit|Sexe| Âge|Occupation|City_Category|Stay_In_Current_City_Years|Marital_Status|Product_Category_1|Product_Category_2|Product_Category_3|Achat|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|1000001| P00069042| F|0-17| 10| A| 2| 0| 3| nul | nul | 8370|

|1000001| P00248942| F|0-17| 10| A| 2| 0| 1| 6| 14| 15200|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

n'affichant que les 2 premières lignes

• Comptage du nombre de lignes de DataFrame

Pour compter le nombre de lignes dans le bloc de données, nous pouvons utiliser l'opération du comptage. Nous allons maintenant compter le nombre de lignes de fichiers de test et de fichiers d'entraînement en appliquant l'opération de comptage.

train.count(),test.count()

Sortir:

(233598, 550069)

Nous avons respectivement 233598, 550069, lignes dans test & train.

• Obtenir le nombre de colonnes et le nom des colonnes à partir du fichier test et train

Semblable à l'opération de la colonne dans DataFrame de pandas, nous utiliserons l'opération des colonnes pour obtenir le nom de la colonne. Maintenant, nous allons d'abord imprimer le no. de la colonne et le nom de la colonne du fichier test et du fichier train.

len(train.columns), train.columns

Sortir:

12 ['User_ID', 'Product_ID', 'Sexe', 'Âge', 'Profession', 'City_Category', 'Stay_In_Current_City_Years', 'Matrital_Status', 'Product_Category_1', 'Product_Category_2', 'Product_Category_3', 'Purchase']

Maintenant, nous le faisons pour le fichier de test de la même manière.

len(test.columns), test.columns

Sortir:

13 [", 'User_ID', 'Product_ID', 'Sexe', 'Age', 'Occupation', 'City_Category', 'Stay_In_Current_City_Years', 'Matrital_Status', 'Product_Category_1', 'Product_Category_2', 'Product_Category_3', 'Comb ']

Après la sortie ci-dessus, nous pouvons voir qu'il y a 12 colonnes dans le fichier de formation et 13 colonnes dans le fichier de test. À partir de la sortie ci-dessus, nous pouvons vérifier que nous avons 13 colonnes dans le fichier de test et 12 dans le fichier de formation. La colonne "Peigne" est la seule colonne unique dans le fichier de test, et il n'y a pas d'"Achat" non présent dans le fichier de test. Il y a une autre colonne dans le fichier de test que nous pouvons voir n'avoir aucun nom de colonne.

• Obtenir les statistiques récapitulatives telles que le nombre, le max, le min, l'écart type, la moyenne dans les colonnes numériques du DataFrame

Dans le DataFrame, nous utiliserons l'opération appelée décrire l'opération. Nous pouvons faire le calcul de la colonne numérique et obtenir un résumé statistique en utilisant décrire l'opération. Toutes les colonnes numériques seront calculées dans le DataFrame, nous il n'y a pas de nom de colonne spécifié dans le calcul des statistiques récapitulatives.

train.describe().show()

Sortir:

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

|résumé| ID_utilisateur| Profession| Marital_Status|Product_Category_1|Product_Category_2|Product_Category_3| Achat|

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

| compter | 550068| 550068| 550068| 550068| 376430| 166821| 550068|

| signifie|1003028.8424013031|8.076706879876669|0.40965298835780306| 5.404270017525106| 9.842329251122386|12.668243206790512| 9263.968712959126|

| stddev|1727.5915855308265|6.522660487341778| 0.4917701263173273|3.9362113692014082| 5.086589648693526| 4.125337631575267|5023.0653938206015|

| min| 1000001| 0| 0| 1| 2| 3| 12|

| max| 1006040| 20| 1| 20| 18| 18| 23961|

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

Dans l'opération de description, c'est ce que nous obtenons lorsque le nom de la colonne de chaîne ou le nom de la colonne catégorielle est spécifié.

train.describe('Product_ID').show()

Sortir:

+——-+———-+

|résumé|ID_produit|

+——-+———-+

| compter | 550068|

| signifie | nul |

| stddev| nul |

| min| P00000142|

| max| P0099942|

+——-+———-+

Basé sur ASCII, les valeurs max et min sont calculées. L'opération Décrire est utilisée pour travailler sur la colonne de type String.

• Sélection de la colonne de DataFrame

Nous utiliserons le nom des colonnes dans l'opération de sélection pour sélectionner la colonne. Nous mentionnerons le nom de la colonne avec la séparation en utilisant des virgules. Nous allons maintenant voir comment se fait la sélection de "Age" et "User_ID" à partir du fichier de formation.

• train.select('User_ID','Age').show(5)
• Sortir:
• +——-+—-+
• |Identifiant_utilisateur| Âge |
• +——-+—-+
• |1000001|0-17|
• |1000001|0-17|
• |1000001|0-17|
• |1000001|0-17|
• |1000002| 55+|
• +——-+—-+
• Trouver le produit Distinct no. dans les fichiers de test et les fichiers d'entraînement

Pour calculer le no. de lignes distinctes, nous utiliserons l' opération distincte . Maintenant, ici, nous allons appliquer une opération distincte pour le calcul de non. de produit distinct dans le dossier test et train.

train.select('Product_ID').distinct().count(),test.select('Product_ID').distinct().count()

Sortir:

(3633, 3492)

Nous avons respectivement 3492 et 3633 produits distincts dans les fichiers test et train. Nous savons maintenant que dans le fichier de formation, nous avons des valeurs plus distinctes que dans le fichier de test, car nous pouvons apprendre du résultat de sortie. Nous allons maintenant utiliser l'opération de soustraction pour trouver les catégories Product_ID qui ne sont pas présentes dans le fichier de formation mais qui sont présentes dans le fichier de test. On peut faire la même chose pour toutes les fonctionnalités de catégorique.

diff_cat_in_train_test=test.select('Product_ID').subtract(train.select('Product_ID'))

diff_cat_in_train_test.distinct().count()# Pour un comptage distinct

Sortir:

46

Ainsi, à partir du résultat ci-dessus, nous pouvons savoir qu'il existe 47 catégories différentes, qui ne sont pas présentes dans le fichier de formation mais sont présentes dans le fichier de test. Les données seront ignorées ou collectées à partir du fichier de test, qui n'est pas présent dans le fichier du train.

• Calcul de la fréquence par paire des colonnes catégorielles ?

Faisons le calcul de la fréquence par paire de la colonne dans le DataFrame en utilisant l'opération can crosstab. Calculons maintenant les colonnes «Sexe» et «Âge» dans DataFrame du train en appliquant une opération de tableau croisé .

train.crosstab('Âge', 'Sexe').show()

Sortir:

+———-+—–+——+

|Âge_Sexe| F| M|

+———-+—–+——+

| 0-17| 5083| 10019|

| 46-50|13199| 32502|

| 18-25|24628| 75032|

| 36-45|27170| 82843|

| 55+| 5083| 16421|

| 51-55| 9894| 28607|

| 26-35|50752|168835|

+———-+—–+——+

La valeur distincte de Gender est le nom de la colonne, et la quantité différente de Age est le nom de la ligne, ce qui peut être vu dans le résultat ci-dessus. Dans le tableau, le décompte de la paire sera égal à zéro s'il ne s'est pas produit.

Comment obtenir DataFrame avec des lignes uniques ?

Pour trouver des lignes uniques et ne pas inclure de lignes en double, nous utiliserons l'opération dropDuplicates . Il obtiendra le Dataframe sans aucune ligne en double en supprimant les lignes en double d'un DataFrame. Veuillez vérifier ici comment la procédure dropDuplicates est effectuée pour obtenir toutes les lignes uniques pour les colonnes.

train.select('Âge','Sexe').dropDuplicates().show()

Sortir:

+—–+——+

| Âge|Sexe|

+—–+——+

|51-55| F|

|51-55| M|

|26-35| F|

|26-35| M|

|36-45| F|

|36-45| M|

|46-50| F|

|46-50| M|

| 55+| F|

| 55+| M|

|18-25| F|

| 0-17| F|

|18-25| M|

| 0-17| M|

+—–+——+

• Comment supprimer des lignes avec une valeur nulle ?

Si l'on veut supprimer toutes les lignes qui ont une valeur nulle, nous pouvons utiliser l'opération appelée opération dropna . Pour supprimer une ligne du DataFrame, il considère trois options.

• Sous-ensemble - c'est la liste de tous les noms des colonnes à prendre en compte pour l'opération de suppression de colonne avec des valeurs nulles.
• Seuil - cela aide à supprimer les lignes avec des valeurs non nulles inférieures au seuil. Par défaut, rien n'est spécifié dans this.
• Comment - Il peut être utilisé en deux types - tout ou partie. En utilisant any, il supprimera la ligne si une valeur de la ligne est nulle. En utilisant all, cela diminuera la ligne si toutes les valeurs des lignes sont nulles.

Maintenant, ici, nous allons utiliser toutes ces options une par une pour supprimer les lignes nulles en utilisant les options par défaut telles que subset, thresh, None for how, none, any.

train.dropna().count()

Sortir:

166821

• Comment remplir les valeurs nulles du DataFrame avec un numéro constant ?

Pour remplir les valeurs nulles avec la constante no. Nous utiliserons ici l' opération fillna . Deux paramètres doivent être pris en compte par l'opération fillna pour remplir les valeurs nulles.

• sous-ensemble : ici, il faut spécifier les colonnes à prendre en compte pour le remplissage des valeurs.
• value : Ici, nous pouvons mentionner le montant à remplacer par quelle valeur, qui peut être n'importe quel type de données tel que string, float, int dans toutes les colonnes.

Ici, nous allons remplir '-1' à la place des valeurs nulles dans le train DataFrame.

train.fillna(-1).show(2)

Sortir:

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|ID_utilisateur|ID_produit|Sexe| Âge|Occupation|City_Category|Stay_In_Current_City_Years|Marital_Status|Product_Category_1|Product_Category_2|Product_Category_3|Achat|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|1000001| P00069042| F|0-17| 10| A| 2| 0| 3| -1| -1| 8370|

|1000001| P00248942| F|0-17| 10| A| 2| 0| 1| 6| 14| 15200|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

n'affichant que les 2 premières lignes

Conclusion

PySpark prend de l'ampleur dans le monde de l'intelligence artificielle et de l'apprentissage automatique. PySpark est utilisé pour résoudre un problème d'apprentissage automatique dans le monde réel. Vous pouvez créer RDD à partir de différentes sources de données à la fois externes et existantes et y effectuer tous les types de transformations. J'espère que cet article a été instructif et a pu vous donner des informations approfondies sur les dataframes PySpark.

Si vous êtes curieux d'en savoir plus sur PySpark et d'autres outils de science des données, consultez le diplôme PG en science des données de IIIT-B & upGrad qui est créé pour les professionnels en activité et propose plus de 10 études de cas et projets, des ateliers pratiques, un mentorat avec experts de l'industrie, 1-on-1 avec des mentors de l'industrie, plus de 400 heures d'apprentissage et d'aide à l'emploi avec les meilleures entreprises.