Jusqu'à ce que pix2 pix-tensorflow soit exécuté par GCML

Enregistrez les étapes pour que pix2pix-tensorflow, qui est une implémentation TensorFlow de pix2pix, fonctionne avec Google Cloud Machine Learning (GCML).

Remplacez l'entrée / la sortie du fichier par tf.gfile

Étant donné que GCML entre et sort des fichiers dans Cloud Storage, remplacez les méthodes d'E / S de fichiers de Python par tf.gfile.

diff --git a/pix2pix.py b/pix2pix.py
index 20ba819..3d1b1c2 100644
--- a/pix2pix.py
+++ b/pix2pix.py
@@ -13,6 +13,11 @@ import collections
 import math
 import time
 
+os.path.exists = tf.gfile.Exists
+glob.glob = tf.gfile.Glob
+os.makedirs = tf.gfile.MakeDirs
+open = tf.gfile.Open
+
 parser = argparse.ArgumentParser()
 parser.add_argument("--input_dir", help="path to folder containing images")
 parser.add_argument("--mode", required=True, choices=["train", "test", "export"
])

J'ai épargné la peine de réécrire la méthode dans l'éditeur et j'ai remplacé la méthode existante par l'équivalent de tf.gfile.

point important

Il n'y a pas de problème avec le code cible cette fois, mais lors de l'ouverture d'un nouveau fichier avec tf.gfile.Open, si vous essayez de le créer avec mode = 'a', il échouera (confirmé avec 1.0.1.). Dans ce cas, il est nécessaire de définir mode = 'w'.

Emballage

Créer un sous-répertoire

Créez un sous-répertoire appelé task et déplacez-y le code principal. Nous avons également besoin d'un fichier "\ __ init__.py" comme moyen d'empaqueter, alors créez-le.

$ mkdir task
$ touch task/__init__.py #Un fichier vide est bien
$ mv pix2pix.py task/

point important

S'il n'est pas complet avec un seul code, il devra être modifié pour prendre en compte les changements d'espace de noms qui accompagnent l'empaquetage. Si pix2pix.py fait référence à model.py, vous devez remplacer la partie "import model" dans pix2pix.py par "from task import model". Cette fois, le processus est terminé avec pix2pix.py uniquement, il n'est donc pas nécessaire de le faire.

Créer setup.py

Créez le fichier setup.py nécessaire à l'empaquetage.

setup.py

# -*- coding: utf-8 -*-
#
from setuptools import setup

if __name__ == '__main__':
    setup(name='task',
          packages=['task'])

Test de fonctionnement local

Vérifiez localement si le résultat modifié fonctionne correctement. Supposons que l'ensemble de données a déjà été téléchargé.

$ gcloud ml-engine local train --module-name=task.pix2pix \
 --package-path=task/ -- \
 --mode train --output_dir /path/to/trained_facades \
 --input_dir /path/to/facades/train --max_epochs 200 \
 --which_direction BtoA'
aspect_ratio = 1.0
batch_size = 1
beta1 = 0.5
checkpoint = None
display_freq = 0
flip = True
gan_weight = 1.0
input_dir = /path/to/facades/train
l1_weight = 100.0
lab_colorization = False
lr = 0.0002
max_epochs = 200
max_steps = None
mode = train
ndf = 64
ngf = 64
output_dir = /path/to/trained_facades
output_filetype = png
progress_freq = 50
save_freq = 5000
scale_size = 286
seed = 1398609485
summary_freq = 100
trace_freq = 0
which_direction = BtoA
examples count = 400
parameter_count = 57183616
progress  epoch 1  step 50  image/sec 0.3  remaining 4224m
discrim_loss 0.573411
gen_loss_GAN 0.376408
gen_loss_L1 0.146523

Si la sortie de la progression est une sortie, on peut considérer qu'elle fonctionne bien.

Lancer un travail sur le cloud

Tout ce que vous avez à faire est de soumettre le travail réel. On suppose que le bucket et les données d'entraînement sont déjà sur Cloud Storage.

$ gcloud ml-engine jobs submit training pix2pix_1 \
 --module-name=task.pix2pix \
 --staging-bucket gs://your-bucket \
 --region us-central1 \
 --scale-tier BASIC_GPU \ #Utiliser une instance GPU
 --package-path=task/ -- \
 --mode train --output_dir gs://your-bucket/output \
 --input_dir gs://your-bucket/facades/train \
--max_epochs 200 --which_direction BtoA
Job [pix2pix_1] submitted successfully.
Your job is still active. You may view the status of your job with the command

  $ gcloud ml-engine jobs describe pix2pix_1

or continue streaming the logs with the command

  $ gcloud ml-engine jobs stream-logs pix2pix_1
jobId: pix2pix_1
state: QUEUED

Vérifiez le journal

Comme vous pouvez le voir dans la sortie ci-dessus, vous pouvez afficher le journal en exécutant la commande glow. Attendons que ce soit fini.

$ gcloud ml-engine jobs stream-logs pix2pix_1
(Omission)
INFO    2017-05-18 18:11:39 +0900       master-replica-0                progress
  epoch 25  step 200  image/sec 4.7  remaining 248m
INFO    2017-05-18 18:11:39 +0900       master-replica-0                discrim_
loss 0.648207
INFO    2017-05-18 18:11:39 +0900       master-replica-0                gen_loss
_GAN 2.13424
INFO    2017-05-18 18:11:39 +0900       master-replica-0                gen_loss_L1 0.318083
INFO    2017-05-18 18:11:39 +0900       master-replica-0                progress  epoch 25  step 250  image/sec 4.7  remaining 247m

Copiez le résultat localement

Copie les résultats stockés sur Cloud Storage localement.

$ cd /your/data/path
$ gsutil cp -r gs://your-bucket/output .

Évaluation

Traitez les données d'évaluation pour voir les résultats.

$ python task/pix2pix.py --mode test \
 --checkpoint /your/data/path/output \
--input_dir /path/to/facades/val \
 --output_dir /your/data/path/test
$ firefox /your/data/path/test/index.html

Code source

https://github.com/knok/pix2pix-tensorflow (gcml branch arbre / gcml)))

À propos des ressources

Ce processus a pris environ 5 heures pour s'entraîner. Le paiement est d'environ 800 yens. Cette fois, le contenu était très petit, 400 feuilles de données, mais avec d'autres ensembles de données, tels que bords2shoes, il y a environ 50 000 images, donc le coût devrait être plus de 10 fois plus élevé.

à partir de maintenant

Puisque le code basé sur cette heure est écrit selon la méthode, une exécution parallèle en GCML est possible avec quelques modifications. J'écrirai sur la façon de le faire.