introduction

Nous mettrons à jour les informations de Kaggle qui a participé dans le passé. Ici, nous allons reprendre l'introduction des données de BOSCH et la discussion de premier plan dans le forum. Pour le code du gagnant du concours et le noyau utile, Résumé Kaggle: BOSCH (gagnant), [Résumé Kaggle: BOSCH (noyaux)](http: // qiita.com/TomHortons/items/359f8e39b9cd424c2360), qui est un résumé et un résumé de discussion. (Le contenu du forum sera ajouté plus tard.)

Cet article utilise Python 2.7, numpy 1.11, scipy 0.17, scikit-learn 0.18, matplotlib 1.5, seaborn 0.7, pandas 0.17. Il a été confirmé qu'il fonctionne sur le notebook jupyter. (Veuillez modifier correctement% matplotlib inline) Si vous trouvez des erreurs lors de l'exécution de l'exemple de script, il serait utile que vous puissiez commenter.

table des matières

Vue d'ensemble
Indice d'évaluation
Présentation des données
Forum
Référence

Contexte

BOSCH est un fabricant mondial de pièces mécaniques. Nous avons nos propres usines de fabrication dans le monde entier et, bien entendu, les produits finis contiennent rarement des produits défectueux. La perte économique causée par ce produit défectueux est importante et la cause du produit défectueux est compliquée. Par conséquent, le but de cette période est de prédire si un produit défectueux ou un bon produit peut être fabriqué sur la base des données d'observation obtenues auprès de l'usine de fabrication de BOSCH.

Les points caractéristiques de cette époque sont les suivants.

Problème extrême de classification binaire: rapport d'échantillon 1000: 1
Se compose de 3 fichiers: fichier numérique, horodatage et données de catégorie
Grand nombre de variables: 1000 variables
Grand nombre d'échantillons: 1 000 000 d'échantillons
Valeurs manquantes: 96% ou plus des données numériques sont des valeurs manquantes
Toutes les données sont anonymisées

2. Indice d'évaluation

L'indice d'évaluation cette fois-ci est MCC.

MCC = \frac{(TP * TN) - (FP * FN)}{\sqrt{(TP + FP)(TP + FN)(TN + FP)(TN + FN)}},

Quant aux données d'étiquetage, la probabilité de produits défectueux est d'environ 1 sur 1000. Par exemple, si l'on prévoit que tous sont de bons produits, le taux de réponse correct dépassera 99%. En utilisant F mesure ou MCC, il est possible d'évaluer correctement ces données extrêmement non uniformes.

De plus, le format du fichier soumis exprime la correspondance entre Id et Réponse en CSV.

Id,Response
1,0
2,1
3,0
etc.

3. Présentation des données

Il existe trois types de ces données.

numeric data
categorical data
date data

Si un produit défectueux se produit, «Réponse» = 1, et s'il s'agit d'un bon produit, «Réponse» = 0. Toutes les données sont (très) volumineuses et anonymisées, et tous les noms de colonnes sont représentés par "ligne de production \ _station \ _features". Par exemple, «L3_S36_F3939» correspond aux données numériques de la 3e ligne, de la 36e station et de la 3939e quantité d'entités.

numeric data Les données sont si volumineuses que la simple lecture des données numériques entraînera l'arrêt du programme sur l'ordinateur portable. Donc, tout d'abord, vérifiez uniquement le nom de la colonne et le nombre d'échantillons. TRAIN_NUMERIC est le chemin vers train_numeric.csv.

`check_numeric.py`


import numpy as np
import pandas as pd

numeric_cols = pd.read_csv(TRAIN_NUMERIC, nrows = 1).columns.values
print numeric_cols
print 'cols.shape: ', numeric_cols.shape

F0 = pd.read_csv(TRAIN_NUMERIC, usecols=(numeric_cols[:2].tolist() + ['Response']))
print 'F0.shape: ', F0.shape

L'exemple d'exécution ressemble à ceci.

array(['Id', 'L0_S0_F0', 'L0_S0_F2', 'L0_S0_F4', 'L0_S0_F6', 'L0_S0_F8',
       'L0_S0_F10', 'L0_S0_F12', 'L0_S0_F14', 'L0_S0_F16', 'L0_S0_F18',
       'L0_S0_F20', 'L0_S0_F22', 'L0_S1_F24', 'L0_S1_F28', 'L0_S2_F32',
       'L0_S2_F36', 'L0_S2_F40', 'L0_S2_F44', 'L0_S2_F48', 'L0_S2_F52',
       'L0_S2_F56', 'L0_S2_F60', 'L0_S2_F64', 'L0_S3_F68', 'L0_S3_F72',
       .....
       'L3_S50_F4245', 'L3_S50_F4247', 'L3_S50_F4249', 'L3_S50_F4251',
       'L3_S50_F4253', 'L3_S51_F4256', 'L3_S51_F4258', 'L3_S51_F4260',
       'L3_S51_F4262', 'Response'], dtype=object)
cols.shape:  (970,)
F0.shape:  (1183747, 2)

Id est un paramètre associé au fichier de date et au fichier de catégorie. Vous pouvez voir qu'il existe 968 variables explicatives pour les produits défectueux. Vous pouvez également voir que le nombre d'échantillons est très élevé à 1 183 747. Chaque variable contient les nombres réels et les valeurs manquantes suivants.

              Id  L0_S0_F0  Response
0              4     0.030         0
1              6       NaN         0
2              7     0.088         0
3              9    -0.036         0

categorical data Regardez les données catégorielles de la même manière. TRAIN_CAT est le chemin vers train_categorical.csv.

`check_category.py`


cat_cols = pd.read_csv(TRAIN_CAT, nrows = 1).columns.values
print 'cat_cols: ', cat_cols
print 'cat_cols.shape: ', cat_cols.shape

cats = pd.read_csv(TRAIN_CAT, usecols=(cat_cols[:2].tolist()))
print 'cats.shape: ', cats.shape
print cats

C'est le résultat de l'exécution.

cat_cols: ['Id' 'L0_S1_F25' 'L0_S1_F27' ..., 'L3_S49_F4237' 'L3_S49_F4239'
 'L3_S49_F4240']

cat_cols.shape:  (2141,)

cats.shape:  (1183747, 2)

              Id L0_S1_F25
0              4       NaN
1              6       NaN
2              7       NaN
3              9       NaN
4             11       NaN
5             13       NaN
6             14       NaN
7             16       NaN
8             18       NaN

Le nombre d'échantillons est le même que numeric_data, et le nombre de variables est de 2141, ce qui est presque le double. La «réponse» n'est pas incluse dans les données de catégorie.

date data Enfin, regardons le fichier de date. TRAIN_DATE est le chemin vers train_date.csv.

`check_date.py`


date_cols = pd.read_csv(TRAIN_DATE, nrows = 1).columns.values
date = pd.read_csv(TRAIN_DATE, usecols=(date_cols[:2].tolist()))

print 'date_cols.shape: ', date_cols.shape
print date_cols
print 'date.shape: ', date.shape
print date

C'est le résultat de l'exécution.

date_cols.shape:  (1157,)
['Id' 'L0_S0_D1' 'L0_S0_D3' ..., 'L3_S51_D4259' 'L3_S51_D4261'
 'L3_S51_D4263']
date.shape:  (1183747, 2)
              Id  L0_S0_D1
0              4     82.24
1              6       NaN
2              7   1618.70
3              9   1149.20
4             11    602.64
5             13   1331.66

Le nombre de variables est de 1157, ce qui est légèrement plus grand que numérique. Le nombre d'échantillons est le même. La fin du nom de la variable passe de F à D, par exemple "L0_S0_D1". Par exemple, L0_S0_D1 signifie l'horodatage de L0_S0_F0 et L0_S0_D3 signifie l'horodatage de L0_S0_F2. Je n'ai pas cherché à savoir pourquoi les variables sont plus que des données numériques.

Forum Voici quelques-unes des interactions exceptionnelles que j'ai trouvées en parcourant les forums. La solution directe et les exemples de programmes apparus dans le forum étant résumés dans un autre article, nous nous concentrerons ici sur le savoir-faire et la discussion générale.

4.1. Que faire en premier si vous avez des données multivariées inconnues

Il y a des données et il y a des étiquettes. Mais je ne sais pas quoi faire en premier. Il y avait un article utile pour ceux qui ont dit.

Puisqu'il peut faire partie de données brutes, visualisez-le d'abord avec un tableau. À ce moment, les valeurs manquantes et les données numériques au-dessus du seuil sont colorées et l'ensemble des données est à peu près confirmé visuellement.
Créez la distribution cumulative des étiquettes que vous souhaitez estimer sur le même graphique pour toutes les variables. À ce stade, vérifiez s'il existe un motif.
Prenez des variables importantes en utilisant une sorte de norme de quantité d'informations telle que feature_importance de XGBoost, gini, entropy. 4.3 Tracez toutes les combinaisons d'entités sélectionnées en 3 à l'aide d'un diagramme de dispersion.

2 ~ 4 sont introduits dans Kaggle Summary: BOSCH (kernels) avec un code spécifique dans 4. EDA présentant des caractéristiques importantes.

J'ai créé l'exemple de code de 2.

Sortez toutes les variables dans un fichier sous la forme violinplot. Veuillez définir le chemin comme vous le souhaitez.

from scipy import stats
import pandas as pd
import numpy as np
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
import seaborn as sns


DATA_DIR = "../input"


TRAIN_NUMERIC = "{0}/train_numeric.csv".format(DATA_DIR)
TEST_NUMERIC = "{0}/test_numeric.csv".format(DATA_DIR)

COL_BATCH = 100
numeric_cols = pd.read_csv(TRAIN_NUMERIC, nrows = 1).columns.values

for n_ in range(len(numeric_cols)/COL_BATCH):
    cols = numeric_cols[(n_*COL_BATCH):(n_*COL_BATCH+COL_BATCH)].tolist()
    train = pd.read_csv(TRAIN_NUMERIC, index_col = 0, usecols=(cols + ['Response']))
    X_neg, X_pos = train[train['Response'] == 0].iloc[:, :-1], train[train['Response']==1].iloc[:, :-1]
    
    BATCH_SIZE = 10
    dummy = []
    source = train.drop('Response', axis=1)

    for n in list(range(0, train.shape[1], BATCH_SIZE)):
        data = source.iloc[:, n:n+BATCH_SIZE]
        data_cols = data.columns.tolist()
        dummy.append(pd.melt(pd.concat([data, train.Response], axis=1), id_vars = 'Response', value_vars = data_cols))
        
    FIGSIZE = (3*(BATCH_SIZE),4*(COL_BATCH/BATCH_SIZE))
    _, axs = plt.subplots(len(dummy), figsize = FIGSIZE)
    for data, ax in zip(dummy, axs):
        v_plots = sns.violinplot(x = 'variable',  y = 'value', hue = 'Response', data = data, ax = ax, split =True)
    v_plots.get_figure().savefig("violin_{0}.jpg ".format(n_))

A propos de la création de dessins en nuage de points de 4

Les données qui contiennent beaucoup de valeurs manquantes comme cette heure ne peuvent pas être affichées sous forme de diagramme de dispersion en l'état. Par conséquent, enregistrez chaque variable à la valeur médiane avant de tracer. Voici un exemple.

import pandas as pd
import numpy as np
import seaborn as sns

features_names = [
    'L0_S11_F298', 'L1_S24_F1672', 'L1_S24_F766', 'L1_S24_F1844',
    'L1_S24_F1632', 'L1_S24_F1723', 'L1_S24_F1846', 'L1_S25_F2761',
    'L1_S25_F2193'
]
features = pd.read_csv(TRAIN_NUMERIC, index_col = 0, usecols=(features_names + ['Response'])).reset_index()
for f in features.columns[:-1]:
    features[f][np.isnan(features[f])] = features[f].median()
    
X_neg, X_pos = features[features['Response'] == 0], features[features['Response']==1]
volumes = len(X_pos) if len(X_pos)<len(X_neg) else len(X_neg)
features = pd.concat([X_pos, X_neg]).reset_index(drop=True)
g = sns.pairplot(features, hue="Response", vars=test.columns.tolist()[:-1], markers='.')

4.2. Que faire si les données sont trop volumineuses

Il semble que les données cette fois peuvent être considérablement réduites en concevant un prétraitement. (Il peut être exécuté même sur un ordinateur portable d'environ 8G)

Discussion 1

a) Supprimer les données en double car les données de catégorie contiennent des doublons b) Comme expliqué dans Introduction au noyau, plus de 95% des fichiers de date sont dupliqués dans chaque station. En les supprimant, vous pourrez utiliser les fonctionnalités de date. c) utiliser toutes les données numériques

a et b peuvent être compris à la suite de l'analyse de ces données. Il est clair que non seulement l'approche d'analyse générale, mais aussi l'approche qui correspond à l'individualité de chaque donnée est importante. J'ai entendu dire que c utilise toutes les données numériques, mais mon PC s'est arrêté. Il semble que cela ne puisse pas être traité en utilisant pandas.read tel quel.

Discussion partie 2

Semblable au commentaire de raddar, il peut être exécuté même avec 8 Go de mémoire, y compris le coût de calcul, en effectuant un prétraitement (suppression de la quantité de fonctionnalités montrant une corrélation parfaite / quantité de fonctionnalités en double). Il n'était pas possible de réaliser un prétraitement aussi sophistiqué. J'espère que vous pouvez le comprendre avec Winner's Code.

4.3. Utilisation de la carte thermique de corrélation et production de données

Bien qu'il y ait beaucoup de variables, il semble qu'il n'y ait pas de matériel de jugement évident dans les données brutes. Par conséquent, la quantité de caractéristiques est générée à partir de la corrélation entre les données. Dans un autre article, j'ai expliqué comment visualiser la différence de coefficient de corrélation lorsqu'un produit défectueux se produit avec une carte thermique. Trouvez des variables utiles pour les problèmes de classification à partir de la carte thermique des coefficients de corrélation

Avec cette méthode, une combinaison de variables dont la corrélation est rompue lorsqu'un produit défectueux se produit est recherchée, et une nouvelle variable est utilisée par PCA (analyse des composants principaux). Comme expliqué en 4.1, puisqu'il contient un grand nombre de valeurs manquantes, il est d'abord complété par la valeur médiane. À ce stade, il peut être possible de générer un nouveau paramètre avec la partie complétée à 1 et la partie non terminée à 0.

4.4. Résolution des problèmes de classification à l'aide de l'apprentissage en profondeur

Récemment, Keras basé sur Tensorflow est utilisé très activement dans Kaggle. Il semble que le surapprentissage en profondeur soit susceptible de se produire dans des données extrêmement non uniformes telles que cette fois, même si le nombre d'échantillons est ajusté ou si un abandon est utilisé. Pourtant, il y avait des gens qui voulaient aborder avec Keras, donc si j'ai le temps plus tard, j'ajouterai une explication.

[PYTHON] Résumé de Kaggle: BOSCH (intro + discussion du forum)