0. Introduction

Soudainement, les données chronologiques sont difficiles à gérer, n'est-ce pas? De plus, je pense que plus vous avez de variables, plus vous risquez de vous briser le cœur. Mais, "Une fois que vous avez extrait les caractéristiques des données de séries chronologiques, vous pouvez faire autre chose!" Je pense qu'il y a beaucoup de monde.

Cette fois, nous allons introduire ** tsfresh **, une bibliothèque qui semble être utile pour l'ingénierie de la quantité de caractéristiques des données de séries chronologiques multidimensionnelles.

J'ai évoqué l'article suivant.

1. Installez tsfresh

Je l'ai installé via pip. Vous ne pouvez pas installer à partir de pip sans mettre à jour pip, veuillez donc mettre à jour pip.

pip install --upgrade pip

Mettre à niveau le pip avec

pip install tsfresh

Installez tsfresh avec.

Pour le moment, si vous recevez un avertissement indiquant que les pandas ne le prennent pas en charge, veuillez changer la version de pandas.

pip install pandas==0.21

Veuillez changer comme.

Voici la version que j'utilise.

pip: 20.0.2
pandas: 0.21.0
tsfresh: 0.14.1

2. Préparez des données de pseudo séries chronologiques

Trouver des données de séries chronologiques multidimensionnelles était un problème, nous allons donc cette fois utiliser une pseudo-transformation de l'ensemble de données qui peut être téléchargé à partir de tsfresh. (Si vous disposez déjà de vos propres données, veuillez les ignorer.)

Tout d'abord, je peux saisir la procédure avec ces pseudo données, mais le résultat qui en ressort n'est pas du tout intéressant, donc si vous avez vos propres données, je vous recommande de les utiliser.

UEA & UCR Time Series Classification Repository Il semble y avoir beaucoup de données chronologiques qui semblent intéressantes ...

Commencez par charger les données.

`In[1]`



import pandas as pd
import numpy as np

from tsfresh.examples.har_dataset import download_har_dataset, load_har_dataset

download_har_dataset()
df = load_har_dataset()
print(df.shape)
df.head()

Si vous cochez avec, vous pouvez voir que ces données ont 7352 points d'échantillonnage et 128 variables (128 dimensions).

Ensuite, découpez seulement 100 points d'échantillonnage et 50 variables.

`In[2]`


df = df.iloc[0:100, 0:50]
print(df.shape)
df.head()

Cette fois, "Il y a cinq sujets et 10 variables de données chronologiques sont acquises à partir d'un capteur attaché au corps pour classer si les sujets sont des enfants ou des adultes." Imaginez une situation comme celle-ci.

Étant donné que le but de ce temps est de voir à travers le flux de l'ingénierie de la quantité d'entités La correspondance des valeurs est foirée. Bien sûr, il ne peut pas être classé par ces données.

`In[3]`


# id:5 et 10 variables

#Chacune des 10 variables est attribuée à chaque individu (sujet).
df_s1 = df.iloc[:,0:10].copy()
df_s2 = df.iloc[:,10:20].copy()
df_s3 = df.iloc[:,20:30].copy()
df_s4 = df.iloc[:,30:40].copy()
df_s5 = df.iloc[:,40:50].copy()

#Créez une colonne avec chaque identifiant individuel comme valeur.
df_s1['id'] = 'sub1'
df_s2['id'] = 'sub2'
df_s3['id'] = 'sub3'
df_s4['id'] = 'sub4'
df_s5['id'] = 'sub5'

#Réécrivez le nom de variable de chaque colonne.
columns = ['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7', 'x8', 'x9', 'x10', 'id']
df_s1.columns = columns
df_s2.columns = columns
df_s3.columns = columns
df_s4.columns = columns
df_s5.columns = columns

df_s1.head()

Il y a 5 trames de données comme celle-ci.

Bien que ce soit une erreur courante, si vous n'utilisez pas .copy () lors de la division et de l'extraction d'un bloc de données, la valeur d'origine sera modifiée (transmise par référence). J'espère que cet article vous sera utile. Différence de comportement lors de la copie avec = dans les pandas et lors de l'utilisation de copy ()

3. Transformez les données de séries chronologiques en une trame de données correspondante

Selon les Documents officiels, ** extract_features () **, qui est la fonction principale de cet article, a un argument. Le format de passage est spécifié. Le type de données est le type d'objet pandas dataframe, mais il existe trois formats.

--Flat DataFrame

DataFrame empilé (trames de données empilées verticalement) --Dictionary de DataFrames plats

Ce qui précède sont les trois types. Cette fois, je vais le formater dans ce premier format.

id	time	x	y
A	t1	x(A, t1)	y(A, t1)
A	t2	x(A, t2)	y(A, t2)
A	t3	x(A, t3)	y(A, t3)
B	t1	x(B, t1)	y(B, t1)
B	t2	x(B, t2)	y(B, t2)
B	t3	x(B, t3)	y(B, t3)

Continuant de plus tôt,

`In[4]`


df = pd.concat([df_s1, df_s2, df_s3, df_s4, df_s5], axis=0)
print(df['id'].nunique())
df.head()

Comme, une fois connecté,

Ce sera. Le nombre d'identifiants uniques est de 5, ils sont donc concaténés sans aucun problème.

Vous pouvez maintenant le passer à la fonction extract_features ().

4. Extraire des fonctionnalités avec extract_features ()

Pour la trame de données précédente

`In[5]`


from tsfresh import extract_features

df_features = extract_features(df, column_id='id')
df_features.head()

Lorsque vous postulez

Le montant de la fonctionnalité est calculé comme ceci. Il existe 754 de ces fonctionnalités pour une variable. Je pense qu'il y en a beaucoup, mais je pense que c'est utile si vous pensez que la difficulté de gérer les données de séries chronologiques est résolue.

Ce que signifie chaque quantité de caractéristiques est La documentation a un aperçu des fonctionnalités extraites (https://tsfresh.readthedocs.io/en/latest/text/list_of_features.html). Il semble que la quantité de caractéristiques (statistiques) qui nécessite des paramètres soit calculée par plusieurs paramètres.

5. Filtrer les fonctionnalités avec select_features ()

Dans la documentation, après avoir extrait les fonctionnalités comme décrit ci-dessus, [Filtrer les fonctionnalités] (https://tsfresh.readthedocs.io/en/latest/text/feature_filtering.html) est recommandé. La fonction de filtrage de ces fonctionnalités est ** select_features () **. Cette fonction utilise un test d'hypothèse statistique pour sélectionner des entités de sorte que seules les entités susceptibles d'avoir une différence statistiquement significative en fonction de cette caractéristique.

avant ça,

`In[6]`


from tsfresh.utilities.dataframe_functions import impute

df_features = impute(df_features)

Ce faisant, les valeurs ingérables telles que NaN et l'infini sont complétées dans la quantité de caractéristiques obtenue précédemment.

De plus, select_features () réduit les fonctionnalités en fonction de la variable dépendante y, préparez donc les données d'une manière pseudo. Ce y doit être pandas.Series ou numpy.array, comme vous pouvez le voir dans le code source (https://tsfresh.readthedocs.io/en/latest/_modules/tsfresh/feature_selection/selection.html) .. Cette fois,

`In[7]`


from tsfresh import select_features

X = df_features
y = [0, 0, 0, 1, 1]
y = np.array(y)

Préparez une trame de données X avec des fonctionnalités extraites et un tableau numpy de y alloué de manière appropriée.

`In[8]`


X_selected = select_features(X, y)
print(X_selected.shape)
X_selected

Quand tu fais

Bien.

Rien ne sort brillamment. C'est vrai, car les données sont appropriées ... Avec des données appropriées, vous devriez être en mesure de bien sélectionner le montant de la fonction. (Ceux qui pourraient (ou ne pouvaient pas) sélectionner le montant de la fonctionnalité à partir de leurs propres données seraient ravis de pleurer si vous pouviez nous donner un commentaire.)

Bonus. J'ai essayé de compresser dimensionnellement la quantité d'entités par analyse en composantes principales (ACP)

Parce que ça se termine par ça Cette fois, au lieu de sélectionner la quantité de caractéristiques à l'aide du test d'hypothèse statistique, j'ai essayé la compression de dimension avec PCA. C'est comme créer une instance appelée pca, l'ajuster et la transformer à l'aide de cette instance.

Le nombre de n_composants doit être inférieur ou égal au plus petit du nombre d'individus (5 cette fois) et du nombre de fonctionnalités (7540 cette fois).

`In[9]`


from sklearn.decomposition import PCA
pca = PCA(n_components=4)
pca.fit(df_features)
X_PCA = pca.transform(df_features)

Lorsqu'il est transformé en bloc de données et affiché,

`In[10]`


X_PCA = pd.DataFrame( X_PCA )
X_PCA.head()

Ce sera.

plus loin, Python: Essayez l'analyse des composants principaux (PCA) avec scikit-learn Si vous essayez de trouver le taux de cotisation / taux de cotisation cumulé en vous référant à

`In[11]`


print('Taux de contribution de chaque dimension: {0}'.format(pca.explained_variance_ratio_))
print('Taux de cotisation cumulé: {0}'.format(sum(pca.explained_variance_ratio_)))

`out[11]`


Taux de contribution de chaque dimension: [0.30121012 0.28833114 0.22187195 0.1885868 ]
Taux de cotisation cumulé: 0.9999999999999999

Ce sera. peut-être, Il peut être possible de compresser les fonctionnalités avec PCA au lieu de sélectionner les fonctionnalités.

Bien qu'il s'agisse d'un jeu de puissance, si vous utilisez cette série de flux, il semble que vous puissiez échapper aux tracas propres à la série chronologique.

De là [Kaggle] Construction du modèle de base, traitement du pipeline Vous pouvez faire diverses choses comme créer un modèle de base comme celui-ci.

Ensuite, je vais l'essayer avec des données de séries chronologiques multidimensionnelles réelles.

[PYTHON] [Kaggle] J'ai essayé l'ingénierie de quantité de caractéristiques de données de séries chronologiques multidimensionnelles à l'aide de tsfresh

0. Introduction

1. Installez tsfresh

2. Préparez des données de pseudo séries chronologiques

In[1]

In[2]

In[3]

3. Transformez les données de séries chronologiques en une trame de données correspondante

In[4]

4. Extraire des fonctionnalités avec extract_features ()

In[5]

5. Filtrer les fonctionnalités avec select_features ()

In[6]

In[7]

In[8]