Dataswati's test

Imports

In [1]:
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
In [2]:
import os
In [3]:
from sklearn.preprocessing import StandardScaler, MinMaxScaler
In [4]:
DATADIR = "wave_data/"

Introduction

Vous trouverez dans le répertoire wave_data/ des signaux qui ont été générés pour l'exercice, nous allons vous demander de faire quelques manipulations afin de lire, transformer, analyser, etc.

Le but de cet exercice est simplement de valider que vous êtes en mesure de prendre rapidement en main python si vous devez rejoindre l'équipe. Il s'agit principalement de faire appel à des fonctions et des modules que nous utilisons régulièrement.

Si vous n'avez jamais fait de python, vous pouvez facilement trouver des éléments de réponses sur internet, et écrire du code fonctionnel.

Une fois le notebook rempli, il ne vous reste plus qu'à nous le renvoyer par email à l'adresse : [email protected]

import et visualisation du code

Ouvrir un des fichiers du répertoire wave_data à l'aide de numpy via la fonction genfromtxt

In [5]:
lst_signal = []
dirs = os.listdir(DATADIR)
for file in dirs:
    lst_signal.append(np.genfromtxt(DATADIR + file))

len(lst_signal)
Out[5]:
100

Ouvrir et regrouper l'ensemble des signaux dans le répertoire wave_data/ dans une liste regroupant des numpy.array.

Former une seconde liste de même taille, contenant le numéro du fichier associé au signal dans la première liste à la même position, au format entier (le numéro étant x dans signal_x.txt).

Bien évidement les listes devront correspondre, nous conseillons l'utilisation d'une boucle for de os.listdir et des méthode associées au format str tel que str.split.

In [93]:
lst_idx = []
for file in dirs:
    idx = file.split('.')[0].split('_')[1]
    lst_idx.append(idx)

lst_idx = list(map(int, lst_idx))
len(lst_idx)
Out[93]:
100

Afficher quelques plots des signaux en utilisant matplotlib (plt.plot)
Afficher l'ensemble des signaux avec plt.imshow

In [94]:
def plot_signal(arr, num_plots=4, name='signal'):
    plt.figure(figsize=(18, 10), dpi= 60)
    sp_idx = 1
    for i in range(num_plots//2 * 2):
        plt.subplot(num_plots//2, 2, sp_idx)
        plt.plot(arr[i])
        plt.title(name + ' ' + str(lst_idx[i]), fontsize=12)
        sp_idx += 1
    plt.tight_layout() # adjust spacing between subplots to minimize the overlaps
In [95]:
plot_signal(lst_signal) # plots 4 signaux

Pretraitement et featuring

Apres avoir converti la liste en un array de taille (nb_sample, nb_feature), normaliser les signaux en utilisant MinMaxScaler de scikit-learn

In [9]:
arr_signal = np.asarray(lst_signal)
arr_signal.shape # n_sanples x n_features
Out[9]:
(100, 200)
In [10]:
scaler = MinMaxScaler()
scaler.fit(arr_signal)
arr_signal_nor = scaler.transform(arr_signal) # version normalisé

Expliquer ce que fait la fonction.

Il calcule le maximum et le minimum de chaque caractéristique (feature) et les utilise ensuite pour mettre à l'échelle toutes les valeurs de cette caractéristique avec celles de [0,1].

Representer graphiquement avec plot quelques courbes de resultat, cela vous parait il correct? Ce resultat vous parait-il adequat?

In [96]:
plot_signal(arr_signal_nor, name="signal normalisé") # plots 4 signaux

Ils ne sont pas les mêmes qu'à l'origine mais c'est raisonnable car nous avons fait une échelle de valeurs à celles de [0,1]. Par conséquent, les courbes semblent plus étroites (plus bruyantes).

Appliquer la fonction écrite ci-dessous à notre set de données. Ploter quelques resultats.

In [12]:
def global_min_max_rescale(X):
    global_min = np.min(X)
    global_max = np.max(X)
    return (X-global_min)/(global_max-global_min)
In [13]:
arr_signal_global = global_min_max_rescale(arr_signal)
plot_signal(arr_signal_global, name="signal normalisé global") # plots 4 signaux

Expliquer la différence avec la méthode précédente

Dans ce cas, nous calculons min et max de toutes les valeurs dans toutes les features (alors que dans le cas de MinMaxScaler, nous prenons seulement min et max des valeurs dans chaque feature). C'est pourquoi dans le cas de l'utilisation de global_min_max_rescale, on obtient la même forme de plots que ceux qui sont originaux.

OPTIONNEL : Vous pouvez aussi tester d'autres méthodes de scaling, fournies ou non pas sklearn

Nous utilisonsStandardScaler.

In [14]:
scaler = StandardScaler()
scaler.fit(arr_signal)
arr_signal_std = scaler.transform(arr_signal)
plot_signal(arr_signal_std, name="signal std")