Un monde où tout le monde peut facilement créer de l'IA

Avec la sortie du système d'exploitation Windows95 en 1995 et la diffusion des produits matériels au grand public, Internet est devenu un outil que tout le monde peut facilement utiliser. Je pense que cela est décrit comme «le développement de l'infrastructure Internet».

La même chose est sur le point de se produire avec la technologie d'apprentissage automatique. Services tels que DataRobot et Azure Machine Learning Ceci est un exemple typique. Dans le passé, je pense que l'analyse de données par apprentissage automatique était un ** brevet exclusif ** uniquement pour les professions professionnelles telles que les ingénieurs et les data scientists. Cependant, avec l'avènement d'Auto ML, la vague de «démocratisation de l'apprentissage automatique» a commencé.

Cette fois, le but est de le faire (simple).

Qu'est-ce que le ML

Avant de parler d'AML Qu'est-ce que le Machine Learning (ML)? Je vais parler de.

La version anglaise de wikipedia avait la description suivante.

Machine learning (ML) is the study of computer algorithms that improve automatically through experience. It is seen as a subset of artificial intelligence. Machine learning algorithms build a mathematical model based on sample data, known as "training data", in order to make predictions or decisions without being explicitly programmed to do so.

En d'autres termes, on peut dire que "l'avenir est ** prédit ** à partir d'expériences (données) passées sans intervention humaine". Voir la figure ci-dessous. Préparer les données brutes et prédire la «cible» à travers tout le flux de «prétraitement» -> «ingénierie des fonctionnalités» -> «apprentissage» -> «sélection / scoring de modèle» ** Cela s'appelle l'apprentissage automatique **.

Par exemple, lorsque vous souhaitez prédire la météo de demain, il semble que vous puissiez prédire à partir d'informations telles que la météo d'hier et d'aujourd'hui, la température, l'humidité et la direction du vent. À ce moment, «la météo de demain» est exprimée en «cible», et les informations passées telles que «les informations d'hier et d'aujourd'hui» sont exprimées en «données brutes». (Dans ce cas, puisqu'il s'agit de données de séries chronologiques, il y a beaucoup d'autres choses à considérer.)

Il y a deux tâches à résoudre par l'apprentissage automatique: «problème de classification» et «problème de retour». Cette fois, nous nous concentrerons sur le "problème de classification".

Auto ML

Alors, qu'est-ce que Auto ML? Il se réfère à l'apprentissage automatique qui automatise le «prétraitement» → «l'ingénierie de la quantité de caractéristiques» dans l'explication ci-dessus.

Il existe de nombreuses façons de dire Auto ML en un mot, mais le but cette fois est de développer Auto ML qui a les fonctions suivantes et compare la précision de chaque modèle. À l'origine, il est nécessaire d'automatiser des tâches telles que le réglage des paramètres, mais pardonnez-moi cette fois> <

Charger les données à partir du chemin des données
encodage onehot
Compléter les valeurs manquantes par l'une des valeurs "moyenne", "médiane" et "la plus fréquente" --Sélection du montant de la fonction
Recherche Grille
Recherche aléatoire
Matrice mixte --Courbe ROC
Notation

Code entier

Ce code est sur github

Préparation des données

Cette fois, nous utiliserons le familier jeu de données titanesque.

Structure du répertoire

aml
|----data
 |      |---train.csv
 |      |---test.csv
|
|----model
 |      |---Le modèle est enregistré ici
|
|----myaml.inpynb

Prétraitement et ingénierie et apprentissage de la quantité de caractéristiques

Je vais d'abord vous montrer le code d'utilisation. Correspond à l'exemple d'API.

model_data = 'data/train.csv'
scoring_data = 'data/test.csv'

aml = MyAML(model_data, scoring_data, onehot_columns=None)
 aml.drop_cols (['Name', 'Ticket', 'Cabin']) #Ne pas utiliser les informations sur le nom, le billet et la cabine
# Prétraitement et ingénierie de la quantité d'objets (sélection de la quantité d'objets)
aml.preprocessing(target_col='Survived', index_col='PassengerId', feature_selection=False)
# Affichage des résultats de la formation et de la comparaison de modèles (adopte la méthode d'exclusion)
aml.holdout_method(pipelines=pipelines_pca, scoring='auc')

	test	train
gb	0.754200	0.930761
knn	0.751615	0.851893
logistic	0.780693	0.779796
rf	0.710520	0.981014
rsvc	0.766994	0.837220
tree	0.688162	1.000000

Prétraitement

Le prétraitement se réfère ici aux deux suivants. De plus, j'espère que le code suivant pourra être expliqué en grattant uniquement les parties importantes.

encodage onehot
Compléter les valeurs manquantes par l'une des valeurs "moyenne", "médiane" et "la plus fréquente"

encodage onehot

    def _one_hot_encoding(self, X: pd.DataFrame) -> pd.DataFrame:
        ...

        # one_hot_encoding
 si self.ohe_columns vaut None: # colonnes obejct ou category seulement one_hot_encoding
            X_ohe = pd.get_dummies(X,
 dummy_na = True, # NULL est également transformé en une variable factice
 drop_first = True) # Exclure la première catégorie
        
 else: uniquement les colonnes spécifiées par # self.ohe_columns one_hot_encoding
            X_ohe = pd.get_dummies(X,
 dummy_na = True, # NULL est également transformé en une variable factice
 drop_first = True, # Exclure la première catégorie
                                   columns=self.ohe_columns)
        ...

Lorsque la classe MyAML est initialisée, ʻonehot_columns` stockées dans la variable d'instance reçoit une liste de "noms de colonnes que vous voulez encoder avec onehot". Si rien n'est spécifié, les colonnes de la trame de données reçue de type obejct ou category seront encodées en un instant.

Achèvement de la valeur manquante

    def _impute_null(self, impute_null_strategy):
        """
 Compléter les valeurs manquantes avec impute_null_strategy
 Types de impute_null_strategy
 moyenne ... complément avec valeur moyenne
 médiane ... complétée par la médiane
 most_frequent ... Compléter avec la valeur la plus fréquente
        """
        self.imp = SimpleImputer(strategy=impute_null_strategy)
        self.X_model_columns = self.X_model.columns.values
        self.X_model = pd.DataFrame(self.imp.fit_transform(self.X_model),
                                    columns=self.X_model_columns)

La complétion des valeurs manquantes est effectuée à l'aide de la classe SimpleImputer de scikit-learn. ʻImpute_null_strategy` est un argument qui indique ce qu'il faut compléter. La méthode du complément correspondant est la suivante.

--mean ... Complété par la valeur moyenne

médiane ... Complété par la médiane --most_frequent ... Complément avec la valeur la plus fréquente

Ingénierie de la quantité de fonctionnalités

L'ingénierie de la quantité d'entités est également profonde, mais cette fois nous allons la simplifier et considérer "la sélection de quantité d'entités par ** forêt aléatoire **".

    def _feature_selection(self, estimator=RandomForestClassifier(n_estimators=100, random_state=0), cv=5):
        """
 Sélection de fonctionnalité
 @param estimator: apprenant pour effectuer la sélection de fonctionnalités
        """
        self.selector = RFECV(estimator=estimator, step=.05, cv=cv)
        self.X_model = pd.DataFrame(self.selector.fit_transform(self.X_model, self.y_model),
                              columns=self.X_model_columns[self.selector.support_])
        self.selected_columns = self.X_model_columns[self.selector.support_]

La première ligne initialise la classe RFECV. Dans ce cas, l'estimateur spécifie «RandomForestClassifier» comme valeur par défaut. Dans la ligne suivante, sélectionnez les quantités de caractéristiques les plus importantes. Enfin, stockez ** les éléments sélectionnés ** dans la variable d'instance selected_columns.

Apprentissage

La méthode holdout compare la compatibilité du modèle avec les données. La méthode d'exclusion est une méthode de séparation des données d'entraînement (données utilisées pour l'entraînement du modèle) et des données de test (données pour la vérification non utilisées pour l'entraînement). Dans cette méthode, les données d'entraînement sont toujours des données d'entraînement et les données de test sont toujours des données de test.

La validation croisée est également implémentée comme un autre moyen de comparer la compatibilité du modèle et des données, mais l'explication est omise.

    def holdout_method(self, pipelines=pipelines_pca, scoring='acc'):
        """
 Vérifiez la précision du modèle par la méthode de maintien
 @param piplines: Pipeline (Dictionnaire des modèles à essayer)
 @param scoring: indice d'évaluation
 acc: taux de réponse correct
 auc: aire de la courbe ROC
        """
        X_train, X_test, y_train, y_test = train_test_split(self.X_model,
                                                            self.y_model,
                                                            test_size=.2,
                                                            random_state=1)
        y_train=np.reshape(y_train,(-1))
        y_test=np.reshape(y_test,(-1))

        scores={}
        for pipe_name, pipeline in pipelines.items():
            pipeline.fit(X_train, y_train)
            joblib.dump(pipeline, './model/'+ pipe_name + '.pkl')
            if scoring == 'acc':
                scoring_method = accuracy_score
            elif scoring == 'auc':
                scoring_method = roc_auc_score
            scores[(pipe_name, 'train')] = scoring_method(y_train, pipeline.predict(X_train))
            scores[(pipe_name, 'test')] = scoring_method(y_test, pipeline.predict(X_test))
        display(pd.Series(scores).unstack())

Ici, la variable «piplines» a le format suivant.

 make pipelines for PCA
pipelines_pca={
    """
 'Nom du modèle': Pipeline ([('scl', classe de normalisation)
 , ('pca', classe pour l'analyse en composantes principales)
 , ('est', modèle)])
    """
    'knn': Pipeline([('scl', StandardScaler())
                      , ('pca', PCA(random_state=1))
                      , ('est', KNeighborsClassifier())]),
    
    'logistic': Pipeline([('scl', StandardScaler())
                            , ('pca', PCA(random_state=1))
                            , ('est', LogisticRegression(random_state=1))]), 
    
     ...
}

Chacune des trois classes confinées à la classe Pipeline exécute les fonctions suivantes.

'scl': normaliser
'pca': Effectuer une analyse en composantes principales
'est': modèle

Par conséquent, au moment de pipeline.fit (X_train, y_train), une série de flux de "standardisation" -> "analyse de quantité de caractéristiques par analyse en composantes principales" -> "apprentissage" est effectuée.

My Dream

J'ai un rêve. «C'est la réalisation d'une société où tout le monde peut facilement créer des modèles d'apprentissage automatique et d'apprentissage en profondeur afin que l'Internet puisse être utilisé par n'importe qui. Comme première étape dans le développement de l'infrastructure d'IA, nous avons mis en place un "système dans lequel une série de processus d'apprentissage automatique peuvent être exploités simplement en passant par un chemin". Il y a encore de nombreux endroits que je n'ai pas encore atteints, mais je continuerai à faire de mon mieux.

[PYTHON] J'ai fait ma propre AML