モデル組み込み失敗中の状態

Author: terapyon

Dockerfile.tf

@@ -0,0 +1,17 @@
+FROM tensorflow/tensorflow:1.12.0-py3
+
+RUN mkdir /code
+RUN mkdir /code/log
+WORKDIR /code
+
+RUN pip install -U pip setuptools
+ADD requirements.txt .
+ADD . /code/
+RUN pip install -e . -c requirements-detector.txt
+
+#RUN pip freeze > /work/requirements.txt
+
+# EXPOSE 8080
+CMD ["python","mahjong_sample_web_app/detector/detector.py"]
+# CMD ["uwsgi","--emperor","/code/uwsgi.ini", "--logto", "/code/log/emperor.log"]
+# CMD ["/bin/sh"]

README.md

@@ -43,4 +43,9 @@ $ pytest -v
 ```
 $ docker build . -t local/mahjong_sample
 $ docker run --rm -it -p 8080:8080 -v $PWD/log:/code/log local/mahjong_sample
+```
+
+```
+$ docker build -t local/mahjong_sample_tf -f Dockerfile.tf .
+$ docker run --rm -it local/mahjong_sample_tf
 ```

mahjong_sample_web_app/detector/detector.py

@@ -4,8 +4,8 @@
 # from scipy.misc import imresize
 from PIL import Image as pil_image
 from keras.preprocessing import image
-from .postprocess import PostProcess
-from .ssd.ssd import SingleShotMultiBoxDetector
+from postprocess import PostProcess
+from ssd.ssd import SingleShotMultiBoxDetector
 
 
 model_file = Path(__file__).parent / "models" / "weights.25-0.05.hdf5"
@@ -18,8 +18,8 @@ def model_build(model_file, param_file):
     ssd = SingleShotMultiBoxDetector(
         overlap_threshold=0.5, nms_threshold=0.45, max_output_size=400
     )
-    ssd.load_parameters(param_file)
-    ssd.build(init_weight=model_file)
+    ssd.load_parameters(str(param_file))
+    ssd.build(init_weight=str(model_file))
     return ssd
 
 
@@ -75,3 +75,9 @@ def detect(img_obj):
     # pp.save_image(img, pred_result, savepath)
     # print(list_label)
     return list_label
+
+
+if __name__ == "__main__":
+    ssd = model_build(model_file, param_file)
+    print(ssd)
+

mahjong_sample_web_app/detector/ssd/ssd.py

@@ -10,55 +10,70 @@
 class SingleShotMultiBoxDetector:
     """
     """
+
     available_type = ["ssd300", "ssd512"]
     available_net = ["vgg16", "resnet50", "xception"]
 
     ar_presets = dict(
-        ssd300=[[2., 1/2.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2.],
-                [2., 1/2.]],
-        ssd512=[[2., 1/2.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2., 3., 1/3.],
-                [2., 1/2.],
-                [2., 1/2.]]
+        ssd300=[
+            [2.0, 1 / 2.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0],
+            [2.0, 1 / 2.0],
+        ],
+        ssd512=[
+            [2.0, 1 / 2.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0, 3.0, 1 / 3.0],
+            [2.0, 1 / 2.0],
+            [2.0, 1 / 2.0],
+        ],
     )
     scale_presets = dict(
-        ssd300=[(30., 60.),
-                (60., 111.),
-                (111., 162.),
-                (162., 213.),
-                (213., 264.),
-                (264., 315.)],
-        ssd512=[(20.48, 51.2),
-                (51.2, 133.12),
-                (133.12, 215.04),
-                (215.04, 296.96),
-                (296.96, 378.88),
-                (378.88, 460.8),
-                (460.8, 542.72)]
-    )
-    default_shapes = dict(
-        ssd300=(300, 300, 3)
+        ssd300=[
+            (30.0, 60.0),
+            (60.0, 111.0),
+            (111.0, 162.0),
+            (162.0, 213.0),
+            (213.0, 264.0),
+            (264.0, 315.0),
+        ],
+        ssd512=[
+            (20.48, 51.2),
+            (51.2, 133.12),
+            (133.12, 215.04),
+            (215.04, 296.96),
+            (296.96, 378.88),
+            (378.88, 460.8),
+            (460.8, 542.72),
+        ],
     )
+    default_shapes = dict(ssd300=(300, 300, 3))
 
-    def __init__(self, n_classes=1, class_names=["bg"], input_shape=None,
-                 aspect_ratios=None, scales=None, variances=None,
-                 overlap_threshold=0.5, nms_threshold=0.45,
-                 max_output_size=400,
-                 model_type="ssd300", base_net="vgg16"):
+    def __init__(
+        self,
+        n_classes=1,
+        class_names=["bg"],
+        input_shape=None,
+        aspect_ratios=None,
+        scales=None,
+        variances=None,
+        overlap_threshold=0.5,
+        nms_threshold=0.45,
+        max_output_size=400,
+        model_type="ssd300",
+        base_net="vgg16",
+    ):
         """
         """
         self.n_classes = n_classes
         self.class_names = class_names
         if "bg" != class_names[0]:
-            print("Warning: Fist label should be bg."
-                  " It'll be added automatically.")
+            print("Warning: Fist label should be bg." " It'll be added automatically.")
             self.class_names = ["bg"] + class_names
             self.n_classes += 1
         if input_shape:
@@ -101,86 +116,93 @@ def build(self, init_weight="keras_imagenet"):
         """
         # create network
         if self.model_type == "ssd300" and self.base_net == "vgg16":
-            self.model, priors = SSD300_vgg16(self.input_shape,
-                                              self.n_classes,
-                                              self.aspect_ratios,
-                                              self.scales)
+            self.model, priors = SSD300_vgg16(
+                self.input_shape, self.n_classes, self.aspect_ratios, self.scales
+            )
         elif self.model_type == "ssd300" and self.base_net == "resnet50":
-            self.model, priors = SSD300_resnet50(self.input_shape,
-                                                 self.n_classes,
-                                                 self.aspect_ratios,
-                                                 self.scales)
+            self.model, priors = SSD300_resnet50(
+                self.input_shape, self.n_classes, self.aspect_ratios, self.scales
+            )
         elif self.model_type == "ssd300" and self.base_net == "xception":
-            self.model, priors = SSD300_xception(self.input_shape,
-                                                 self.n_classes,
-                                                 self.aspect_ratios,
-                                                 self.scales)
+            self.model, priors = SSD300_xception(
+                self.input_shape, self.n_classes, self.aspect_ratios, self.scales
+            )
         elif self.model_type == "ssd512" and self.base_net == "vgg16":
-            self.model, priors = SSD512_vgg16(self.input_shape,
-                                              self.n_classes,
-                                              self.aspect_ratios,
-                                              self.scales)
+            self.model, priors = SSD512_vgg16(
+                self.input_shape, self.n_classes, self.aspect_ratios, self.scales
+            )
         elif self.model_type == "ssd512" and self.base_net == "resnet50":
-            self.model, priors = SSD512_resnet50(self.input_shape,
-                                                 self.n_classes,
-                                                 self.aspect_ratios,
-                                                 self.scales)
+            self.model, priors = SSD512_resnet50(
+                self.input_shape, self.n_classes, self.aspect_ratios, self.scales
+            )
         else:
             raise NameError(
                 "{},{} is not defined. types are {}, basenets are {}.".format(
-                    self.model_type, self.base_net,
-                    self.available_type, self.available_net
+                    self.model_type,
+                    self.base_net,
+                    self.available_type,
+                    self.available_net,
                 )
             )
 
         if init_weight is None:
             print("Network has not initialized with any pretrained models.")
         elif init_weight == "keras_imagenet":
-            print("Initializing network with keras application model"
-                  " pretrained imagenet.")
+            print(
+                "Initializing network with keras application model"
+                " pretrained imagenet."
+            )
             if self.base_net == "vgg16":
                 import keras.applications.vgg16 as keras_vgg16
+
                 weights_path = keras_vgg16.get_file(
-                    'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
+                    "vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5",
                     keras_vgg16.WEIGHTS_PATH_NO_TOP,
-                    cache_subdir="models"
+                    cache_subdir="models",
                 )
             elif self.base_net == "resnet50":
                 import keras.applications.resnet50 as keras_resnet50
+
                 weights_path = keras_resnet50.get_file(
-                    'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
+                    "resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5",
                     keras_resnet50.WEIGHTS_PATH_NO_TOP,
-                    cache_subdir="models"
+                    cache_subdir="models",
                 )
             elif self.base_net == "xception":
                 import keras.applications.xception as keras_xception
+
                 weights_path = keras_xception.get_file(
-                    'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
+                    "xception_weights_tf_dim_ordering_tf_kernels_notop.h5",
                     keras_xception.TF_WEIGHTS_PATH_NO_TOP,
-                    cache_subdir="models"
+                    cache_subdir="models",
                 )
             else:
-                raise NameError(
-                    "{} is not defined.".format(
-                        self.base_net
-                    )
-                )
+                raise NameError("{} is not defined.".format(self.base_net))
             self.model.load_weights(weights_path, by_name=True)
         else:
             print("Initializing network from file {}.".format(init_weight))
             self.model.load_weights(init_weight, by_name=True)
 
         # make boundary box class
-        self.bboxes = BoundaryBox(n_classes=self.n_classes,
-                                  default_boxes=priors,
-                                  variances=self.variances,
-                                  overlap_threshold=self.overlap_threshold,
-                                  nms_threshold=self.nms_threshold,
-                                  max_output_size=self.max_output_size)
+        self.bboxes = BoundaryBox(
+            n_classes=self.n_classes,
+            default_boxes=priors,
+            variances=self.variances,
+            overlap_threshold=self.overlap_threshold,
+            nms_threshold=self.nms_threshold,
+            max_output_size=self.max_output_size,
+        )
 
-    def train_by_generator(self, gen, epoch=30, neg_pos_ratio=3.0,
-                           learning_rate=1e-3, freeze=None, checkpoints=None,
-                           optimizer=None):
+    def train_by_generator(
+        self,
+        gen,
+        epoch=30,
+        neg_pos_ratio=3.0,
+        learning_rate=1e-3,
+        freeze=None,
+        checkpoints=None,
+        optimizer=None,
+    ):
         """
         """
         # set freeze layers
@@ -196,14 +218,13 @@ def train_by_generator(self, gen, epoch=30, neg_pos_ratio=3.0,
         if checkpoints:
             callbacks.append(
                 keras.callbacks.ModelCheckpoint(
-                    checkpoints,
-                    verbose=1,
-                    save_weights_only=True
-                ),
+                    checkpoints, verbose=1, save_weights_only=True
+                )
             )
 
         def schedule(epoch, decay=0.9):
-            return learning_rate * decay**(epoch)
+            return learning_rate * decay ** (epoch)
+
         callbacks.append(keras.callbacks.LearningRateScheduler(schedule))
 
         if optimizer is None:
@@ -216,20 +237,17 @@ def schedule(epoch, decay=0.9):
 
         self.model.compile(
             optimizer=optim,
-            loss=MultiBoxLoss(
-                self.n_classes,
-                neg_pos_ratio=neg_pos_ratio
-            ).compute_loss
+            loss=MultiBoxLoss(self.n_classes, neg_pos_ratio=neg_pos_ratio).compute_loss,
         )
         history = self.model.fit_generator(
             gen.generate(self.preprocesser, True),
-            int(gen.train_batches/gen.batch_size),
+            int(gen.train_batches / gen.batch_size),
             epochs=epoch,
             verbose=1,
             callbacks=callbacks,
             validation_data=gen.generate(self.preprocesser, False),
-            validation_steps=int(gen.val_batches/gen.batch_size),
-            workers=1
+            validation_steps=int(gen.val_batches / gen.batch_size),
+            workers=1,
         )
 
         return history
@@ -245,7 +263,7 @@ def save_parameters(self, filepath="./param.json"):
             base_net=self.base_net,
             aspect_ratios=self.aspect_ratios,
             scales=self.scales,
-            variances=self.variances
+            variances=self.variances,
         )
         print("Writing parameters into {}.".format(filepath))
         json.dump(params, open(filepath, "w"), indent=4, sort_keys=True)
@@ -264,23 +282,27 @@ def load_parameters(self, filepath):
         self.scales = params["scales"]
         self.variances = params["variances"]
 
-    def detect(self, X, batch_size=1, verbose=0,
-               keep_top_k=200, confidence_threshold=0.01,
-               do_preprocess=True):
+    def detect(
+        self,
+        X,
+        batch_size=1,
+        verbose=0,
+        keep_top_k=200,
+        confidence_threshold=0.01,
+        do_preprocess=True,
+    ):
         """
         """
         if do_preprocess:
             inputs = self.preprocesser(X.copy())
         else:
             inputs = X.copy()
 
-        predictions = self.model.predict(inputs,
-                                         batch_size=batch_size,
-                                         verbose=verbose)
+        predictions = self.model.predict(inputs, batch_size=batch_size, verbose=verbose)
         detections = self.bboxes.detection_out(
             predictions,
             keep_top_k=keep_top_k,
-            confidence_threshold=confidence_threshold
+            confidence_threshold=confidence_threshold,
         )
 
         return detections