CIGBM TTIS ABouraoui TD/TP BigData

Correction Série Big Data

Exercice 1 :
Parmi les affirmations suivantes dites lesquelles sont vraies :
Corrigé :
1. Vrai, HDFS est conçu pour gérer une quantité relativement faible de fichiers
volumineux. Un système de fichiers hiérarchique peut donc être géré
efficacement par un seul NameNode.
2. Faux, la taille par défaut est de 64 ou 128 mégaoctets mais cela peut être
facilement modifié dans la configuration.
3. Faux, le client écrit des données dans les DataNodes. Aucune donnée ne
passe par le NameNode.
4. Vrai, chaque DataNode peut exécuter plusieurs tâches d'application
simultanément.
5. Vrai, étant donné que chaque DataNode peut exécuter plusieurs tâches
simultanément, il peut y avoir plus de clients que de DataNodes.
6. Vrai, et une image de cet espace de noms est également conservée dans le
système de fichiers NameNode.
7. Faux, les emplacements des répliques de bloc peuvent changer au fil du
temps et ne font pas partie d’un point de contrôle persistant.
8. Faux, la taille du fichier de données est égale à la longueur réelle du bloc et
ne nécessite pas d'espace supplémentaire pour l'arrondir à la taille de bloc
nominale comme dans les systèmes de fichiers traditionnels. Par conséquent,
80 mégaoctets seront stockés sous la forme d'un bloc de 64 mégaoctets + un
bloc de 16 mégaoctets.
Exercice 2
Corrigé :
1. La taille typique d'un bloc est de 64 ou 128 mégaoctets. Une grande taille de
bloc offre plusieurs avantages importants.
1.a. Il minimise le coût des recherches. Si le bloc est suffisamment grand, le
temps nécessaire pour transférer les données depuis le disque peut être
considérablement plus long que le temps nécessaire pour rechercher le

1
CIGBM TTIS ABouraoui TD/TP BigData

début du bloc. Ainsi, le transfert d'un fichier volumineux composé de

plusieurs blocs fonctionne au taux de transfert du disque.

-Cela réduit le besoin des clients d'interagir avec le NameNode car les lectures
et les écritures sur le même bloc ne nécessitent qu'une seule demande initiale
au NameNode pour les informations de localisation. La réduction est
significative pour les charges de travail où les applications lisent et écrivent
principalement des fichiers volumineux de manière séquentielle.
-Étant donné que sur un grand bloc, un client est plus susceptible d'effectuer
de nombreuses opérations sur le bloc donné, il peut réduire la surcharge du
réseau en conservant une connexion TCP persistante au DataNode sur une
période prolongée.
-Il réduit la taille des métadonnées stockées sur le NameNode. Cela nous
permet de garder les métadonnées en mémoire.
2. Linéairement. HDFS est conçu en tenant compte des pannes de machine, et
donc les DataNodes n'ont pas besoin d'être des machines très fiables (très
chères). Au lieu de cela, du matériel de base standard peut être utilisé. De plus,
le nombre de nœuds peut être augmenté dès que cela devient nécessaire,
évitant le gaspillage de ressources lorsque la quantité de données est encore
limitée. C'est en effet le principal avantage du « scaling out » par rapport au
« scaling up », qui a une croissance exponentielle des coûts.
3. Avant Hadoop 2.0.0, le NameNode était un point de défaillance unique. Alors
que la perte de toute autre machine (intermittente ou permanente) n'entraîne
pas de perte de données, la perte de NameNode entraîne l'indisponibilité du
cluster. La perte permanente des données sur NameNode rendrait le HDFS du
cluster inutilisable.
La fonctionnalité de haute disponibilité HDFS résout les problèmes ci-dessus en
offrant la possibilité d'exécuter deux NameNodes redondants dans le même
cluster dans une configuration active/passive avec un serveur de secours.
3.1. Le Secondary namenode est un nœud qui fusionne périodiquement les
fichiers « fsimage et les editlogs » des modifications et maintient la taille du
journal des modifications dans une limite. Cela permet au NameNode de
démarrer plus rapidement en cas de panne. L'équipe HDFS a continué à

2
CIGBM TTIS ABouraoui TD/TP BigData

améliorer les nœuds de nom "alternatifs" et a proposé presque chaque année

un nouveau nom avec de nouvelles fonctionnalités améliorant les anciens.
Exercice 3
Corrigé :
a. Évolutivité : en partitionnant les fichiers en blocs et en les distribuant à de
nombreux serveurs fonctionnant en parallèle, HDFS peut évoluer vers un grand
nombre de fichiers de n'importe quelle taille. En ajoutant plus de DataNodes, la
capacité de stockage du système peut être augmentée de manière arbitraire. Il
a été démontré qu'il peut évoluer au-delà de dizaines de pétaoctets (PB). Plus
important encore, il le fait avec des caractéristiques de performance et un coût
linéaires.
b. Durabilité : HDFS crée plusieurs copies de chaque bloc (par défaut 3, sur
différents racks) pour minimiser la probabilité de perte de données.
c. Hautes performances de lecture/écriture séquentielle : en divisant des
fichiers volumineux en blocs et en les répartissant sur plusieurs machines. Cela
rend les lectures parallèles possibles (accès à différents nœuds en même
temps) soit en utilisant plusieurs clients, soit en utilisant un cadre de
traitement de données distribué tel que MapReduce.
Exercice 4
Exercice sur la stratégie de sauvegarde de blocs sur HDFS.
Supposons que votre cluster HDFS est composé de 3 racks, chacun contenant 3
DataNodes. Supposons également que le HDFS est configuré pour utiliser une
taille de bloc de 100 mégaoctets et qu'un client se connecte depuis l'extérieur
du centre de données (par conséquent, aucun DataNode n'est privilégié).
Le client télécharge un fichier de 150 mégaoctets.
1. Dessinez dans l'image ci-dessous une configuration de blocs possible en
fonction de la politique de réplication HDFS par défaut.
Pour chaque bloc indépendamment, la politique de placement du HDFS consiste à placer
une réplique sur un nœud aléatoire dans un rack aléatoire, une autre sur un nœud dans un
rack différent et la dernière sur un nœud différent dans le même rack choisi pour la
deuxième réplique. Une configuration possible est montrée dans l'image (mais il y a
beaucoup plus de solutions valables).

3
CIGBM TTIS ABouraoui TD/TP BigData

2. Combien y a-t-il de répliques pour chaque bloc ? Où sont stockées ces

répliques ?
On pourrait décider de stocker les 3 répliques dans 3 racks différents, augmentant ainsi la
disponibilité attendue. Cependant, cela ralentirait également le processus d'écriture qui
impliquerait deux communications inter-racks au lieu d'une. Habituellement, la probabilité
de défaillance d'un rack entier est beaucoup plus faible que la probabilité de défaillance
d'un nœud et c'est donc un bon compromis d'avoir 2/3 des répliques dans un rack.

3. En vous référant à l'image ci-dessous, supposons qu'un bloc est stocké

dans le nœud 3, ainsi que dans les nœuds 4 et 5. Si ce bloc de données
doit être traité par une tâche s'exécutant sur le nœud 6, laquelle des
trois répliques sera réellement lu par le nœud 6 ?
Soit celui stocké dans le nœud 4 ou le nœud 5, en supposant que la topologie intra-rack est
telle que la distance entre ces nœuds et le nœud 6 est la même. En général, la priorité de
lecture est uniquement basée sur la distance, et non sur le premier nœud sélectionné lors
du processus d'écriture.

4
CIGBM TTIS ABouraoui TD/TP BigData

Pour avoir une idée de la façon dont les données circulent entre le client
interagissant avec HDFS, considérez un diagramme ci-dessous qui montre les
principaux composants de HDFS.

4. Dessinez la séquence principale d'événements lorsqu'un client copie un fichier

sur HDFS.
5. Dessinez la séquence principale d'événements lorsqu'un client lit un fichier à
partir de HDFS.
6. Pourquoi pensez-vous qu'un client écrit des données directement sur les
datanodes au lieu de les envoyer via le namenode ?
Solution :

4. Les étapes 2 à 5 sont appliquées pour chaque bloc du fichier.

5
CIGBM TTIS ABouraoui TD/TP BigData

1. Le client HDFS demande au Namenode de créer le fichier.

2. Le client HDFS demande au Namenode un DataNode pour héberger la réplique du

i-ème bloc du fichier.

3. NameNode répond avec une liste de DataNodes et leurs emplacements pour le i-

ème bloc.

4. Le client écrit le i-ème bloc dans les DataNodes en mode pipeline.

5. Les DataNodes du pipeline d'écriture accusent réception de l'écriture d'un bloc.

Une fois que tous ont répondu, le premier DataNode contacté répond avec accusé
de réception au client.

6. Le client envoie au NameNode une requête pour fermer le fichier et libérer le

verrou.

7. Les DataNodes vérifient avec le NameNode pour une réplication minimale.

8. Le NameNode envoie un accusé de réception au client à la fin de l'écriture du

fichier.

5 . Lecture

1. Le client HDFS demande un fichier

2. NameNode répond avec une liste de blocs et les emplacements de chaque réplique.

6
CIGBM TTIS ABouraoui TD/TP BigData

3. Le client lit chaque bloc à partir du nœud de données le plus proche.

6. Si le namenode était responsable de la copie de tous les fichiers vers les datanodes, cela deviendrait
un goulot d'étranglement

Exercice 5

1. Calculez les distances suivantes en utilisant la règle de distance expliquée ci-

dessus :
-Nœud 0 et nœud 1  2
-Nœud 0 et nœud 2  4
-Nœud 1 et nœud 4  6
-Nœud 4 et nœud 5  4
-Nœud 2 et nœud 3  2

7
CIGBM TTIS ABouraoui TD/TP BigData

-Deux processus du nœud 1  0

Exercice 6
1. XML …
2. Créez le fichier JSON correspondant aux indications suivantes :

1. Créer la racine du fichier json.

Remarque : si la racine est un objet alors {}
Si la racine représente un tableau : []
2. Ajoutez les attributs suivants dans la racine du JSON :
hôpital, de type string.
service, de type string.
date, de type number.
patients, de type tableau.
3. Ajoutez 4 patients dans le tableau, chaque patients a 3 attributs : nom
(string), prenom (string) et numéro SS (number).

Corrigé :

{
"hôpital": "Habib Thameur",
"service" : "urgence"
"date": 03032012,
"patients": [
{
"nom": "Memmi",
"prenom": "Mohammed",
"numeroSS" : 0101020445
},
{
"nom": "Ben Ali",
"prenom": "Samira",
"numeroSS" : 02147485
},
{
"nom": "Mathlouthi",
"prenom": "Tarek",
"numeroSS" : 08789852

}
]
}

Exercice 7
Dans cet exercice on va s’entraîner à faire de l’analyse de données en utilisant
Python.

8
CIGBM TTIS ABouraoui TD/TP BigData

1. Graphiques et visualisation
Ouvrir le site http://catalog.industrie.gov.tn/dataset/demande-annuelle-d-energie-
primaire. Sinon le fichier et fourni sur Google classroom.
Télécharger le dataset TN-Demande annuelle d'énergie primaire. (Excell)
Ouvrir Python localement, ou en utilisant Google Colab ou Juoyter Notes.
Charger le dataset.
Il s’agit de construire un graphique qui permettra de mieux exprimer les données
visuellement. (Time-series par exemple).
Lib à utiliser : matplotlib.
a. Tout d’abord récupérer le contenu du fichier dans un DataFrame
b. Imprimez le contenu à l’écran
c. Jouez un peu avec les fonctions head et tail de DF
d. Changez les noms de colonne du DataFrame pour que ce soit plus pratique.
e. Imprimez quelques colonnes isolées.
f. Construire une courbe simple qui exprime la consommation d’électricité
primaire entre 1990 et 2021. Comme dans l’image ci-dessous.

g. Donner un titre au graphique, une légende à l’abscisse et une légende à l’axe

des ordonnées.
h. Changer la couleur de la courbe de bleu à vert.
i. Changer la courbe en graphique à barres (bar plot).
j. Introduire dans le même graphique 2 ou 3 types d’énergie (faites attention aux
plages de valeurs). Choisissez le type de graphique que vous préférez. Jouez
sur la couleur. Introduire une légende explicite pour chaque courbe comme
dans l’exemple ci-dessous.

9
CIGBM TTIS ABouraoui TD/TP BigData

Vous aurez besoin de :

-récupérer les données dans un dataframe (pandas)
-utiliser matplotlib.pyplot pour rendre les graphiques à l’écran
-lire le fichier excel dans le df
-vous débarrasser des colonnes vides ou inutiles (nettoyer les données)
-fonctions drop et readexcel de pandas
-fonctions title, xlabel, ylabel, plot, bar, barh et show de pyplot
Exercice 8
Corrigé :

import matplotlib.pyplot as plt

import pandas as pd
from scipy import stats

df = pd.read_csv("univariate_linear_regression_dataset.csv")
#selection de la première colonne de notre dataset (la taille de la population)
X = df.iloc[0:len(df),0]
#selection de deuxième colonnes de notre dataset (le profit effectué)
Y = df.iloc[0:len(df),1]
plt.title("Exemple de regression pour le chapitre 5")
plt.scatter(X,Y)
# X et Y sont les variables qu'on a extraites du dataframe
plt.grid() # dessiner une grille pour une meilleure lisibilité du graphe

10
CIGBM TTIS ABouraoui TD/TP BigData

#linregress() renvoie plusieurs variables de retour. On s'interessera

# particulierement au slope et intercept
#cette fonction va retourner les var d'un modèle de regression linéaire
slope, intercept, r_value, p_value, std_err = stats.linregress(X, Y)
#voici comment à partir des var slope et intercept définir la fonction F(x) cherchée
def predict(x):
return slope * x + intercept
#Ceci permet de faire une prédiction sur la population
#la variable fitLine sera un tableau de valeurs prédites depuis la tableau de variables X
fitLine = predict(X)
plt.plot(X, fitLine, c='r')

plt.show()
Exercice 9
from textblob import TextBlob
from langdetect import detect
import nltk
import sys
text = "Aujourd'hui j'ai vu un film. Il s'appelle Alien. Je ne crois pas que ce soit un bon
film"
blob = TextBlob(text)
print(blob)
Sentences=blob.sentences
print (Sentences)
Words=blob.words
print(Words)
Tags=blob.tags
print(Tags)
lg=detect (str(blob))
print(lg)
sent=blob.sentiment
print(sent)

11
CIGBM TTIS ABouraoui TD/TP BigData

tr1=blob.translate(from_lang=lg, to='en')
print(tr1)
tr2=blob.translate(from_lang=lg, to='ar')
tr3=str(tr2).encode('utf-8')
sys.stdout.buffer.write(tr3)

//corriger l’orthographe
print(b.correct())

Exercice 10
import numpy as np
import cv2
import matplotlib.pyplot as plt
original_image = cv2.imread("clustersampleimage.jpeg")
img=cv2.cvtColor(original_image,cv2.COLOR_BGR2RGB)
vectorized = img.reshape((-1,3))
vectorized = np.float32(vectorized)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
K=5
attempts=10
ret,label,center=cv2.kmeans(vectorized,K,None,criteria,attempts,cv2.KMEANS_PP_
CENTERS)
center = np.uint8(center)
res = center[label.flatten()]
result_image = res.reshape((img.shape))
figure_size = 15
plt.figure(figsize=(figure_size,figure_size))
plt.subplot(1,2,1),plt.imshow(img)
plt.title('Image originale'), plt.xticks([]), plt.yticks([])
plt.subplot(1,2,2),plt.imshow(result_image)
plt.title('Image segmentée avec K = %i' % K), plt.xticks([]), plt.yticks([])
plt.show()

12
CIGBM TTIS ABouraoui TD/TP BigData

13