Modèle d'apprentissage automatique prenant en compte la maintenabilité

Ancien emploi

Mon travail précédent était le développement de logiciels (Java, C #). Là, nous avons également effectué des revues de code détaillées basées sur la directive d'écrire un code propre et efficace.

Titulaire

Je suis en charge de l'analyse de données-apprentissage automatique. Je vais l'écrire en Python, mais si ce n'est pas une version commerciale, il n'y a pas de révision de code et c'est une atmosphère que cela devrait fonctionner. .. Certes, la cible de l'analyse, le modèle et les paramètres changent fréquemment, donc je pense que c'est le résultat plutôt que de travailler dur sur la conception.

Introduction d'objets

Cependant, je déteste le code qui définit plusieurs modèles (par exemple, régression multiple, SVR, Lasso, RandomForestRegressor) dans un bloc-notes Jupyter et envoie chaque modèle, et séparer les blocs-notes pour chaque modèle gère également plus de fichiers. Je déteste ça parce que c'est un problème. Par conséquent, le notebook à déplacer n'est pas falsifié (pour vérifier le résultat), et le modèle est spécifié à partir de la configuration et exécuté, ce qui le rend un peu orienté objet. Je suis sûr qu'il y a des gens qui disent: "L'apprentissage automatique et les modèles d'ordinateurs portables ne le sont pas". ..

Vue d'ensemble

N'indiquez pas le nom de modèle unique sur le notebook Jupyter. Dans ce qui suit, le modèle est créé suite à sa génération par ClassCreator.
Quel que soit ce modèle, le côté notebook jupyter ne le sait pas. Appelez simplement la méthode abstraite définie.

    clazz_path = parser.get(path="regression", key="class_path")
    model = ClassCreator.create(clazz_path)

Dans le fichier de configuration, définissez comme suit

[regression]
class_path = utility.SVRModel.SVRModel

Dans ClassCreator, instancier avec réflexion J'ai fait référence à ici.

import sys

class ClassCreator():
    @staticmethod
    def create(class_path):
        try:
            print("class:", class_path)
            component_path = str(class_path).split('.')
            package_path   = component_path[:-1]
            package_name   = ".".join(package_path)
            class_name     = component_path[-1]
            __import__(str(package_name))
            cls = getattr(sys.modules[package_name], class_name)
            return cls()
        except Exception as e:
            print('===contenu de l'erreur===')
            print('type:' + str(type(e)))
            print('args:' + str(e.args))
            print('soi-même:' + str(e))

Classe abstraite Le contenu est gratuit, mais il ressemble à ceci comme un échantillon.

from abc import ABCMeta, abstractmethod


class AbstractModel(metaclass=ABCMeta):

    @abstractmethod
    def run_grid_search(self, x_train_scaled, y_train):
        pass

    @abstractmethod
    def create_and_pred(self, x_train_scaled, y_train, x_test_scaled):
        pass

    @abstractmethod
    def print_eval(self, x_train_scaled, x_test_scaled, y_train, y_test, df):
        pass

    @abstractmethod
    def get_score(self, x_test_scaled, y_test):
        pass

    @abstractmethod
    def get_rmse(self, y_test, pred):
        pass

    @abstractmethod
    def get_modeltype(self):
        pass

    @abstractmethod
    def get_best_params(self):
        pass

Classe de béton (par exemple SVR) Puisqu'il est nécessaire d'appeler GridSearchCV dans SVR, il est défini comme suit. La méthode abstraite à appeler n'est pas bonne pour PoC, il y a donc un dicton "Je n'en ai pas besoin".

from sklearn.svm import SVR
from sklearn.model_selection import GridSearchCV
import numpy as np
from sklearn.metrics import mean_squared_error
from utility.AbstractModel import AbstractModel

class SVRModel(AbstractModel):

    def __init__(self):
        self.clr = SVR()
        self.regr = None
        self.grid_search = None

    def run_grid_search(self, x_train_scaled, y_train):
        param_grid = {'C': [0.005, 0.0075, 0.1, 0.25, 0.4, 0.5, 0.6, 0.75, 1],
                      'epsilon': [0.000001, 0.00005, 0.00001, 0.0001, 0.0005, 0.001]}
        self.grid_search = GridSearchCV(self.clr, param_grid, cv=5)
        self.grid_search.fit(x_train_scaled, y_train)
        print("best param: {}".format(self.grid_search.best_params_))
        print("best score: {}".format(self.grid_search.best_score_))
        return self.grid_search

    def create_and_pred(self, x_train_scaled, y_train, x_test_scaled):
        self.regr = SVR(C=self.grid_search.best_params_["C"], epsilon=self.grid_search.best_params_["epsilon"])
        self.regr.fit(x_train_scaled, y_train)
        return self.regr.predict(x_test_scaled)

    def print_eval(self, x_train_scaled, x_test_scaled, y_train, y_test, df):
        if self.regr is None:
            raise Exception("needs to run 'create_and_pred' method before call this method.")

        print("Convient aux données de test")
        print("Exactitude des données d'entraînement(Facteur de décision r^2 score,corrélation) =", self.regr.score(x_train_scaled, y_train))
        print("Exactitude des données de test(Facteur de décision r^2 score,corrélation) =", self.regr.score(x_test_scaled, y_test))
        pred = self.regr.predict(X=x_test_scaled)
        print("RMSE:", np.sqrt(mean_squared_error(y_test, pred)))

    def get_score(self, x_test_scaled, y_test):
        return self.regr.score(x_test_scaled, y_test)

    def get_rmse(self, y_test, pred):
        return np.sqrt(mean_squared_error(y_test, pred))

    def get_modeltype(self):
        return type(self.clr)

    def get_best_params(self):
        return self.grid_search.best_params_

Bien sûr, je pense qu'il y a une meilleure forme. Quoi qu'il en soit, contrairement au développement de système, c'est un code qui se répète avec essais et erreurs, donc Je pense qu'il est important de ne pas l'oublier plus tard.

En utilisant ce formulaire, j'essaierai de créer un modèle avec des exemples de données à l'avenir.