[PYTHON] Parametereinstellung mit luigi

Vor kurzem verwende ich ein Datenfluss-Kontroll-Framework namens luigi, aber ich bin der Meinung, dass es relativ einfach zu verwenden ist. Deshalb werde ich versuchen, einen kleinen Missionstext zu schreiben. ... Es gibt nicht viele japanische Materialien ...

Über Luigi selbst http://qiita.com/colspan/items/453aeec7f4f420b91241 http://qiita.com/keisuke-nakata/items/0717c0c358658964f81e Bitte beachten Sie die ausführliche Beschreibung in.

Um die Güte kurz zu erklären, beendet luigi jede untergeordnete Klasse (= Aufgabe), die luigi.Task erbt, und erhält das gesamte Berechnungsergebnis. Durch die Begrenzung der Datenübertragung auf Dateien kann der bereits berechnete Teil verlassen werden, selbst wenn ein Fehler in der Mitte vorliegt oder das Berechnungszeitlimit überschritten wird, und eine Wiederaufnahme ist möglich. (Möglicherweise kann On-Memory nicht bereitgestellt werden ...? → Nachtrag: luigi.mock

Maschinelles Lernen mit Luigi

Wenn Sie zum Zeitpunkt der Parametereinstellung den Arbeitsspeicher berechnen und dieser in die Mitte fällt, ist es traurig, die gesamte Berechnung zu wiederholen. Also dachte ich, ich könnte die Güte von Luigi nutzen, also schrieb ich den Code vorerst. https://github.com/keisuke-yanagisawa/study/blob/20151204/luigi/param_tuning.py Was du brauchst

• numpy
• scikit-learn
• luigi

Drei von.

Dieses Programm

python param_tuning.py task_param_tuning --local-scheduler

Wenn Sie es tun, wird es ausgeführt. Sie geben die zugrunde liegende Aufgabe an. Außerdem wird luigi normalerweise beim Starten des Schedulers verwendet. Da dies jedoch problematisch ist, versuche ich, es unabhängig mit --local-scheduler auszuführen.

Werfen wir einen Blick auf die Aufgaben.

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)) ); 

Der Code selbst ist ziemlich einfach. Der Bewertungswert wird durch Kreuzvalidierung unter Verwendung von SVR berechnet und der Durchschnittswert wird in die Datei ausgegeben.

Denken Sie daran, dass Luigi-Aufgaben grundsätzlich einen dreiteiligen Satz von ** [erfordert, Ausgabe, Ausführung] ** überschreiben.

• erfordert ... Aufgaben, die zuerst ausgeführt werden müssen, um diese Aufgabe auszuführen
• output ... Ausgabedateipfad für diese Aufgabe (mehrere können angegeben werden)
• run ... Aufgabeninhalt

ist. Der Ausgabedateipfad verwendet einen Zauberspruch namens luigi.LocalTarget ().

Verwenden Sie außerdem luigi.Parameter () usw. als Argument. In luigi habe ich das Gefühl, dass ich mir diese Parameter anschaue und entscheide, dass derselbe Aufgabenname, der unterschiedliche Parameter hat, ausgeführt wird, andernfalls wird dasselbe nicht zweimal ausgeführt. (Daher muss der Parameter hashbar sein.)

Schauen wir uns als nächstes eine Aufgabe an, die die obige Aufgabe mehrmals aufruft.

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]))

Ich lerne mich nicht selbst und weiß nicht, wie ich mehrere Parameter übergeben soll (ich werde wahrscheinlich wütend), also trenne ich sie vorerst durch Kommas, aber lass das in Ruhe. In diesem Code wollte ich Parameter wie C und Gamma von task_param_eval ausgeben, also habe ich im Lauf "` für task in self.requires () "" festgelegt, aber wenn es in Ordnung ist, wenn ich die erforderliche Datei nur lesen kann Wenn "self.input ()" ist, kann der gleiche Effekt wie "self.requires (). Output ()" erzielt werden.