In Teil 1 Von dieser Serie haben wir über das Erstellen wiederverwendbarer Code-Property gesprochen, die über mehrere Projekte hinweg bereitgestellt werden können. Durch die Nutzung eines zentralisierten Repositorys der gemeinsamen Datenwissenschaftsstufen wird sichergestellt, dass Experimente schneller und mit größerem Vertrauen in die Ergebnisse durchgeführt werden können. Eine optimierte Experimentationsphase ist entscheidend, um sicherzustellen, dass Sie das Unternehmen so schnell wie möglich Wert liefern.
In diesem Artikel möchte ich mich darauf konzentrieren, wie Sie die Geschwindigkeit erhöhen können, mit der Sie experimentieren können. Möglicherweise haben Sie 10 -bis -13 -Ideen für verschiedene Setups, die Sie ausprobieren möchten. Wenn Sie sie effizient ausführen, steigern Sie Ihre Produktivität erheblich. Eine vollständige Umschulung, wenn die Modellleistung abfällt und die Einbeziehung neuer Merkmale, wenn sie verfügbar werden, nur einige Situationen erforschen, in denen es zu einem großartigen Segen wird, schnell über Experimente zu iterieren.
Wir müssen über Notizbücher sprechen (wieder)
Während Jupyter -Notizbücher eine großartige Möglichkeit sind, sich Bibliotheken und Konzepte zu unterrichten, können sie leicht missbraucht und zu einer Krücke werden, die aktiv der schnellen Modellentwicklung im Wege steht. Betrachten Sie den Fall eines Datenwissenschaftlers in ein neues Projekt. Die ersten Schritte dienen normalerweise dazu, ein neues Notizbuch zu öffnen und einige explorative Datenanalysen zu beginnen. Verstehen Sie, welche Artwork von Daten Sie Ihnen zur Verfügung stehen, einige einfache Zusammenfassungsstatistiken durchführen, Ihr Ergebnis verstehen und schließlich einige einfache Visualisierungen, um die Beziehung zwischen den Merkmalen und dem Ergebnis zu verstehen. Diese Schritte sind ein nützliches Unterfangen, da besser das Verständnis Ihrer Daten kritisch ist, bevor Sie mit dem Experimentierprozess beginnen.
Das Drawback damit ist nicht in der EDA selbst, sondern was danach kommt. Normalerweise geschieht der Datenwissenschaftler weiter und öffnet sofort ein neues Notizbuch, um ihren Experiment -Framework zu schreiben, der normalerweise mit Datenumwandlungen beginnt. Dies erfolgt in der Regel durch Wiederverwendung von Code-Snippets aus ihrem EDA-Notizbuch, indem sie von einem zum anderen kopiert. Sobald sie ihr erstes Notizbuch bereit haben, wird es ausgeführt und die Ergebnisse werden entweder lokal gespeichert oder an einen externen Ort geschrieben. Diese Daten werden dann von einem anderen Notizbuch aufgegriffen und weiter verarbeitet, z. B. nach Characteristic -Auswahl und dann zurückgeschrieben. Dieser Vorgang wiederholt sich, bis Ihre Experiment-Pipeline aus 5-6 Notizbüchern besteht, die von einem Datenwissenschaftler nacheinander ausgelöst werden müssen, damit ein einzelnes Experiment ausgeführt wird.
Mit einem solchen manuellen Ansatz zum Experimentieren wird die Iterie über Ideen und das Ausprobieren verschiedener Szenarien zu einer arbeitsintensiven Aufgabe. Sie haben eine Parallelisierung auf der Menschenebene, in der sich ganze Groups von Datenwissenschaftlern dem Durchführen von Experimenten widmen, indem sie lokale Kopien der Notizbücher durchführen und ihren Code fleißig bearbeiten, um verschiedene Setups auszuprobieren. Die Ergebnisse werden dann zu einem Bericht hinzugefügt, in dem unter allen anderen nach dem Experimentieren das Setup am besten abgeschlossen ist.
All dies ist nicht nachhaltig. Teammitglieder, die krank gehen oder Urlaub machen, Experimente über Nacht durchführen, in der Hoffnung, dass das Notizbuch nicht abstürzt, und vergessen, welche experimentellen Setups Sie durchgeführt haben und die Sie noch tun müssen. Dies sollten keine Sorgen sein, die Sie beim Ausführen eines Experiments haben. Zum Glück gibt es einen besseren Weg, um in strukturierter und methodischer Weise im Maßstab über Ideen zu iterieren. All dies wird die Experimentationsphase Ihres Projekts erheblich vereinfachen und seine Wertzeit stark verringern.
Umarmen Sie Skripts, um Ihre experimentelle Pipeline zu erstellen
Der erste Schritt zur Beschleunigung Ihrer Experimentierfähigkeit besteht darin, über Notebooks hinauszugehen und mit dem Skript zu beginnen. Dies sollte der einfachste Teil des Prozesses sein. Von dort aus können Sie Ihr Skript aus der Befehlszeile aufrufen, zum Beispiel:
python src/most important.py
if __name__ == "__main__":
input_data = ""
output_loc = ""
dataprep_config = {}
featureselection_config = {}
hyperparameter_config = {}
information = DataLoader().load(input_data)
data_train, data_val = DataPrep().run(information, dataprep_config)
features_to_keep = FeatureSelection().run(data_train, data_val, featureselection_config)
model_hyperparameters = HyperparameterTuning().run(data_train, data_val, features_to_keep, hyperparameter_config)
evaluation_metrics = Analysis().run(data_train, data_val, features_to_keep, model_hyperparameters)
ArtifactSaver(output_loc).save((data_train, data_val, features_to_keep, model_hyperparameters, evaluation_metrics))Beachten Sie, dass die Einhaltung des Prinzips, Ihren Workflow durch Übergabe von Argumenten in Funktionen zu kontrollieren, das Structure Ihrer experimentellen Pipeline erheblich vereinfachen kann. Ein solches Skript hat Ihre Fähigkeit, Experimente auszuführen, bereits verbessert. Sie benötigen nun nur einen einzigen Skript-Aufruf, im Gegensatz zu der Cease-Begin-Artwork, mehrere Notizbücher nacheinander auszuführen.
Möglicherweise möchten Sie diesem Skript einige Eingabeargumente hinzufügen, z. Sie können Ihr Skript problemlos erweitern, um einige Befehlszeilenargumente zu erhalten:
python src/main_with_arguments.py --input_data <loc> --output_loc <loc>
if __name__ == "__main__":
input_data, output_loc = parse_input_arguments()
dataprep_config = {}
featureselection_config = {}
hyperparameter_config = {}
information = DataLoader().load(input_data)
data_train, data_val = DataPrep().run(information, dataprep_config)
features_to_keep = FeatureSelection().run(data_train, data_val, featureselection_config)
model_hyperparameters = HyperparameterTuning().run(data_train, data_val, features_to_keep, hyperparameter_config)
evaluation_metrics = Analysis().run(data_train, data_val, features_to_keep, model_hyperparameters)
ArtifactSaver(output_loc).save((data_train, data_val, features_to_keep, model_hyperparameters, evaluation_metrics))Zu diesem Zeitpunkt haben Sie den Beginn einer guten Pipeline; Sie können den Eingangs- und Ausgabestell festlegen und Ihr Skript mit einem einzigen Befehl aufrufen. Es ist jedoch immer noch ein relativ manuelles Unterfangen, neue Ideen auszuprobieren. Sie müssen in Ihre Codebasis eingehen und Änderungen vornehmen. Wie bereits erwähnt, sollte das Umschalten zwischen verschiedenen Experiment -Setups idealerweise so einfach sein, wie das Eingabeargument in eine Wrapper -Funktion zu ändern, die steuert, was durchgeführt werden muss. Wir können all diese verschiedenen Argumente an einen einzigen Ort bringen, um sicherzustellen, dass das Ändern Ihres experimentellen Setups trivial wird. Die einfachste Artwork und Weise, dies zu implementieren, ist mit einer Konfigurationsdatei.
Konfigurieren Sie Ihre Experimente mit einer separaten Datei
Das Speichern aller relevanten Funktionsargumente in einer separaten Datei bietet mehrere Vorteile. Durch die Aufteilung der Konfiguration von der Haupt -Codebasis wird es einfacher, verschiedene experimentelle Setups auszuprobieren. Sie bearbeiten einfach die relevanten Felder mit der neuen Idee und Sie sind bereit zu gehen. Sie können sogar mühelos ganze Konfigurationsdateien austauschen. Sie haben auch eine vollständige Aufsicht darüber, was genau Ihr experimentelles Setup struggle. Wenn Sie eine separate Datei professional Experiment beibehalten, können Sie zu früheren Experimenten zurückkehren und genau sehen, was ausgeführt wurde.
Wie sieht eine Konfigurationsdatei aus und wie wird sie mit dem von Ihnen erstellten Experiment -Pipeline -Skript angeschlossen? Eine einfache Implementierung einer Konfigurationsdatei besteht darin, die YAML -Notation zu verwenden und auf folgende Weise einzurichten:
- Die obersten booleschen Flaggen auf der obersten Ebene, um die verschiedenen Teile Ihrer Pipeline ein- und auszuschalten
- Definieren Sie für jeden Schritt in Ihrer Pipeline, welche Berechnungen Sie durchführen möchten
file_locations:
input_data: ""
output_loc: ""
pipeline_steps:
data_prep: True
feature_selection: False
hyperparameter_tuning: True
analysis: True
data_prep:
nan_treatment: "drop"
numerical_scaling: "normalize"
categorical_encoding: "ohe"Dies ist eine versatile und leichte Methode, um zu kontrollieren, wie Ihre Experimente ausgeführt werden. Sie können Ihr Skript anschließend so ändern, dass diese Konfiguration geladen wird, und den Workflow Ihrer Pipeline steuern:
python src/main_with_config –config_loc <loc>
if __name__ == "__main__":
config_loc = parse_input_arguments()
config = load_config(config_loc)
information = DataLoader().load(config("file_locations")("input_data"))
if config("pipeline_steps")("data_prep"):
data_train, data_val = DataPrep().run(information,
config("data_prep"))
if config("pipeline_steps")("feature_selection"):
features_to_keep = FeatureSelection().run(data_train,
data_val,
config("feature_selection"))
if config("pipeline_steps")("hyperparameter_tuning"):
model_hyperparameters = HyperparameterTuning().run(data_train,
data_val,
features_to_keep,
config("hyperparameter_tuning"))
if config("pipeline_steps")("analysis"):
evaluation_metrics = Analysis().run(data_train,
data_val,
features_to_keep,
model_hyperparameters)
ArtifactSaver(config("file_locations")("output_loc")).save((data_train,
data_val,
features_to_keep,
model_hyperparameters,
evaluation_metrics))Wir haben jetzt die Einrichtung unseres Experiments aus dem Code, der ihn ausführt, vollständig entkoppelt. Welcher experimentelle Setup, den wir ausprobieren möchten, wird jetzt vollständig von der Konfigurationsdatei bestimmt, sodass es trivial ist, neue Ideen auszuprobieren. Wir können sogar steuern, welche Schritte wir ausführen möchten, und Szenarien ermöglichen:
- Ausführen von Datenvorbereitung und Characteristic -Auswahl nur, um einen anfänglichen verarbeiteten Datensatz zu generieren, der die Grundlage für ein detaillierteres Experimentieren zum Ausprobieren verschiedener Modelle und verwandter Hyperparameter bilden kann
Nutzen Sie die Automatisierung und Parallelität
Wir können nun verschiedene experimentelle Setups über eine Konfigurationsdatei konfigurieren und das vollständige Finish-to-Finish-Experiment mit einem einzigen Befehlszeilenaufruf starten. Alles, was zu tun bleibt, ist die Fähigkeit zu skalieren, über verschiedene Experiment -Setups so schnell wie möglich zu iterieren. Der Schlüssel dazu ist:
- Automatisierung Um die Konfigurationsdatei programmatisch zu ändern
- Parallele Ausführung von Experimenten
Schritt 1) ist relativ trivial. Wir können ein Shell -Skript oder sogar ein sekundäres Python -Skript schreiben, dessen Aufgabe über verschiedene experimentelle Setups iterativ ist, die der Benutzer liefert, und dann eine Pipeline mit jedem neuen Setup starten.
#!/bin/bash
for nan_treatment in drop impute_zero impute_mean
do
update_config_file($nan_treatment, <config_loc>)
python3 ./src/main_with_config.py --config_loc <config_loc>
executed;Schritt 2) ist ein interessanteres Angebot und ist sehr State of affairs abhängig. Alle Experimente, die Sie durchführen, sind selbst enthalten und haben keine Abhängigkeit voneinander. Dies bedeutet, dass wir alle gleichzeitig theoretisch starten können. Praktisch beruht es darauf, dass Sie Zugriff auf externe Berechnung haben, entweder intern oder als Cloud-Service-Anbieter. Wenn dies der Fall ist, kann jedes Experiment als separater Auftrag in Ihrem Laptop gestartet werden, vorausgesetzt, Sie haben Zugriff auf die Verwendung dieser Ressourcen. Dies beinhaltet jedoch andere Überlegungen, wie z. B. die Bereitstellung von Docker -Bildern, um eine konsistente Umgebung über Experimente hinweg zu gewährleisten und herauszufinden, wie Sie Ihren Code in den externen Laptop einbetten können. Sobald dies jedoch gelöst ist, sind Sie jetzt in der Lage, so viele Experimente zu starten, wie Sie möchten, nur durch die Ressourcen Ihres Rechenanbieters begrenzt.
Einbettungslogger und Experiment -Tracker für eine einfache Aufsicht einbetten
Die Fähigkeit, 100 parallele Experimente zum externen Laptop zu starten, ist ein klarer Sieg auf dem Weg, um die Zeit auf den Wert von Datenwissenschaftsprojekten zu verringern. Wenn Sie jedoch diesen Prozess abstrahieren, ist es mit den Kosten verbunden, dass er nicht so einfach zu befragen ist, insbesondere wenn etwas schief geht. Die interaktive Natur der Notizbücher ermöglichte es, einen Zellblock auszuführen und das Ergebnis sofort zu betrachten.
Das Verfolgen des Fortschritts Ihrer Pipeline kann durch die Verwendung eines Loggers in Ihrem Experiment realisiert werden. Sie können wichtige Ergebnisse erfassen, z. B. die Funktionen, die vom Auswahlprozess ausgewählt wurden, oder es verwenden, um das, was derzeit in der Pipeline auszuführen ist, zu zeigen. Wenn etwas schief gehen sollte, können Sie die von Ihnen erstellten Protokolleinträge verweisen, um herauszufinden, wo das Drawback aufgetreten ist, und dann möglicherweise mehr Protokolle einbetten, um das Drawback besser zu verstehen und zu lösen.
logger.information("Splitting information into practice and validation set")
df_train, df_val = create_data_split(df, methodology = 'random')
logger.information(f"coaching information measurement: {df_train.form(0)}, validation information measurement: {df_val.form(0)}")
logger.information(f"treating lacking information through: {missing_method}")
df_train = treat_missing_data(df_train, methodology = missing_method)
logger.information(f"scaling numerical information through: {scale_method}")
df_train = scale_numerical_features(df_train, methodology = scale_method)
logger.information(f"encoding categorical information through: {encode_method}")
df_train = encode_categorical_features(df_train, methodology = encode_method)
logger.information(f"variety of options after encoding: {df_train.form(1)}")Der letzte Aspekt des Begins großer paralleler Experimente besteht darin, effiziente Wege zu finden, um sie schnell zu finden, um das Setup mit der besten Leistung schnell zu finden. Wenn Sie Ereignisprotokolle durchlesen oder Leistungsdateien für jedes Experiment individuell öffnen müssen, wird die harte Arbeit, die Sie geleistet haben, schnell rückgängig machen, um einen optimierten experimentellen Prozess sicherzustellen.
Am einfachsten ist es, einen Experiment -Tracker in Ihr Pipeline -Skript einzubetten. Es gibt eine Vielzahl von 1st und 3Rd Celebration -Instruments zur Verfügung, mit der Sie einen Projektraum einrichten und dann die wichtigen Leistungsmetriken jedes experimentellen Setups protokollieren können, das Sie berücksichtigen. Normalerweise kommen sie ein konfigurierbares Frontend, mit dem Benutzer einfache Handlungen zum Vergleich erstellen können. Dies wird das Finden des Experiments zum besten darstellenden Experiment zu einem viel einfacheren Unterfangen machen.
Abschluss
In diesem Artikel haben wir untersucht, wie man Pipelines erstellt Experimentieren Verfahren. Dies beinhaltete das Auszug aus Notizbüchern und die Konvertierung Ihres Experimentiervorgangs in ein einzelnes Skript. Dieses Skript wird dann durch eine Konfigurationsdatei gesichert, die die Einrichtung Ihres Experiments steuert, wodurch es trivial ist, verschiedene Setups durchzuführen. Der externe Laptop wird dann genutzt, um die Ausführung der Experimente zu parallelisieren. Schließlich sprachen wir über die Verwendung von Holzfällern und Experiment -Trackern, um Ihre Experimente aufrechtzuerhalten und ihre Ergebnisse leichter zu verfolgen. All dies ermöglicht es Datenwissenschaftlern, ihre Fähigkeit, Experimente durchzuführen, erheblich zu beschleunigen, sodass sie die Zeit für den Wert ihrer Projekte verkürzen und das Unternehmen schneller zu Ergebnissen liefern können.