Réglage des paramètres avec luigi

Récemment, j'utilise un framework de contrôle de flux de données appelé luigi, mais je pense que c'est relativement facile à utiliser, donc je vais essayer d'écrire un petit texte missionnaire. ... Il n'y a pas beaucoup de matériaux japonais ...

À propos de Luigi lui-même http://qiita.com/colspan/items/453aeec7f4f420b91241 http://qiita.com/keisuke-nakata/items/0717c0c358658964f81e Veuillez vous référer à la description détaillée dans.

Pour expliquer brièvement les avantages, luigi termine chaque classe enfant (= tâche) qui hérite de luigi.Task et obtient le résultat du calcul complet. En limitant le transfert des données aux fichiers, même s'il y a un bogue au milieu ou que le temps de calcul est dépassé, la partie déjà calculée peut être laissée et la reprise est possible. (Peut-être que la mémoire en mémoire ne peut pas être livrée ...? → Addendum: luigi.mock

Apprentissage automatique avec Luigi

Si vous calculez en mémoire au moment du réglage des paramètres et que cela tombe au milieu, il est triste de refaire tout le calcul. Donc, j'ai pensé que je pourrais utiliser les bienfaits de luigi, alors j'ai écrit le code pour le moment. https://github.com/keisuke-yanagisawa/study/blob/20151204/luigi/param_tuning.py De quoi as-tu besoin

• numpy
• scikit-learn
• luigi

Trois de.

Ce programme

python param_tuning.py task_param_tuning --local-scheduler

Si vous le faites, il fonctionnera. Vous allez spécifier la tâche sous-jacente. De plus, luigi est généralement utilisé en lançant le planificateur, mais comme c'est gênant, j'essaye de l'exécuter indépendamment avec --local-scheduler.

Jetons un coup d'œil aux tâches.

class task_param_eval(luigi.Task):
    data = luigi.Parameter()
    C = luigi.FloatParameter()
    gamma = luigi.FloatParameter()

    def requires(self):
        return []
    def output(self):
        return luigi.LocalTarget("temp/%s.txt" % hash( frozenset([self.C, self.gamma]) ))
    def run(self):
        model = svm.SVR(C=self.C, gamma=self.gamma)

        # cross_val_score function returns the "score", not "error". 
        # So, the result is inverse of error value.
        results = -cross_validation.cross_val_score(model, data.data, data.target, scoring="mean_absolute_error")
        with self.output().open("w") as out_file:
            out_file.write( str(np.mean(results)) ); 

Le code lui-même est assez simple. La valeur d'évaluation est calculée par validation croisée à l'aide de SVR et la valeur moyenne est sortie dans le fichier.

Gardez à l'esprit que les tâches luigi écrasent essentiellement un ensemble de 3 éléments de ** [requires, output, run] **.

• nécessite ... Tâches qui doivent être effectuées en premier lieu pour effectuer cette tâche
• output ... Chemin du fichier de sortie pour cette tâche (plusieurs peuvent être spécifiés)
• exécuter ... le contenu de la tâche

est. Le chemin du fichier de sortie utilise un sort magique appelé luigi.LocalTarget ().

Utilisez également luigi.Parameter () etc. comme argument. À l'intérieur de luigi, j'ai l'impression de regarder ces paramètres et de décider que si le même nom de tâche a des paramètres différents, il sera exécuté, sinon la même chose ne sera pas exécutée deux fois. (Par conséquent, le paramètre doit être haché)

Ensuite, regardons une tâche qui appelle la tâche ci-dessus plusieurs fois.

class task_param_tuning(luigi.Task):

    cost_list = luigi.Parameter(default="1,2,5,10")
    gamma_list = luigi.Parameter(default="1,2,5,10")
    
    data = datasets.load_diabetes()

    def requires(self):
        return flatten_array(
            map(lambda C:
                    map(lambda gamma:
                            task_param_eval(data=frozenset(self.data), # values should be hashable 
                                       C=float(C), gamma=float(gamma)),
                        self.cost_list.split(",")),
                self.gamma_list.split(",")))
    def output(self):
        return luigi.LocalTarget("results.csv")
    def run(self):

        results = {}

        for task in self.requires():
            with task.output().open() as taskfile:
                results[(task.C, task.gamma)] = float(taskfile.read())
        
        best_key = min(results,  key=results.get)
        with self.output().open("w") as out_file:
            out_file.write("%s,%s,%.4f\n" %(best_key[0], best_key[1], results[best_key]))

Je ne m'étudie pas moi-même et je ne sais pas comment passer plusieurs paramètres (je suis susceptible de me mettre en colère), alors je les sépare par des virgules pour le moment, mais laissez cela de côté. Dans ce code, je voulais afficher des paramètres tels que C et gamma de task_param_eval, j'ai donc défini pour la tâche dans self.requires () '' dans l'exécution, mais si c'est OK si je peux lire le fichier require purement Si est self.input () '', le même effet que `` self.requires (). Output () '' peut être obtenu.