validation - kamangir/bolt#689

abcli/fashion_mnist.sh

@@ -1,15 +1,15 @@
 #! /usr/bin/env bash
 
 function fashion_mnist() {
-    abcli_fashion_mnist $@
-}
-
-function abcli_fashion_mnist() {
     local task=$(abcli_unpack_keyword $1 help)
 
     if [ $task == "help" ] ; then
-        abcli_help_line "fashion_mnist task_1" \
-            "run fashion_mnist task_1."
+        abcli_help_line "fashion_mnist ingest" \
+            "ingest fashion_mnist data."
+        abcli_help_line "fashion_mnist predict object_1" \
+            "run fashion_mnist model object_1 predict."
+        abcli_help_line "fashion_mnist train" \
+            "train fashion_mnist."
 
         if [ "$(abcli_keyword_is $2 verbose)" == true ] ; then
             python3 -m fashion_mnist --help
@@ -18,12 +18,34 @@ function abcli_fashion_mnist() {
         return
     fi
 
-    if [ "$task" == "task_1" ] ; then
+    if [ "$task" == "ingest" ] ; then
         python3 -m fashion_mnist \
-            task_1 \
+            thing \
+            --destination $abcli_object_path \
             ${@:2}
         return
     fi
 
+    if [ "$task" == "predict" ] ; then
+        abcli_fashion_mnist ingest
+        abcli_image_classifier_predict ${@:2}
+    fi
+
+    if [ "$task" == "train" ] ; then
+        abcli_fashion_mnist ingest
+        abcli_image_classifier_train \
+            "$2" \
+            "$3" \
+            "$4" \
+            --color 0 \
+            --convnet 0 \
+            ${@:5}
+        return
+    fi
+
     abcli_log_error "-fashion_mnist: $task: command not found."
+}
+
+function abcli_fashion_mnist() {
+    fashion_mnist $@
 }

abcli/image_classifier.sh

@@ -0,0 +1,92 @@
+#! /usr/bin/env bash
+
+function abcli_image_classifier() {
+    local task=$(abcli_unpack_keyword "$1" help)
+
+    if [ "$task" == "help" ] ; then
+        abcli_help_line "$abcli_cli_name image_classifier describe object_1" \
+            "describe model object_1."
+        abcli_help_line "$abcli_cli_name image_classifier predict object_1 object_2" \
+            "run image_classifier model object_1 predict on data object_2."
+        abcli_help_line "$abcli_cli_name image_classifier train object_1" \
+            "train image_classifier on data object_1."
+
+        if [ "$(abcli_keyword_is $2 verbose)" == true ] ; then
+            python3 -m fashion_mnist.image_classifier --help
+        fi
+        return
+    fi
+
+    if [[ $(type -t abcli_image_classifier_$task) == "function" ]] ; then
+        abcli_image_classifier_$task ${@:2}
+        return
+    fi
+
+    if [ "$task" == "describe" ] ; then
+        local model_object_name="$2"
+
+        abcli_download $model_object_name
+
+        python3 -m fashion_mnist.image_classifier \
+            describe \
+            --model_path $abcli_object_root/$model_object_name \
+            ${@:3}
+
+        return
+    fi
+
+    abcli_log_error "-fashion_mnist: image-classifier: $task: command not found."
+}
+
+function abcli_image_classifier_predict() {
+    local model_object=$(abcli_clarify_object "$1")
+    local data_object=$(abcli_clarify_object "$2")
+
+    abcli_download $model_object
+    abcli_download $data_object
+
+    abcli_log "image_classifier($model_object).predict($data_object)"
+
+    if [ ! -f "$abcli_object_root/$data_object/test_images.pyndarray" ] ; then
+        python3 -m fashion_mnist.image_classifier \
+            preprocess \
+            --infer_annotation 0 \
+            --model_path $abcli_object_root/$model_object \
+            --objects $abcli_object_root/$data_object \
+            --output_path $abcli_object_root/$data_object \
+            --purpose predict \
+            ${@:3}
+    fi
+
+    cp -v ../$data_object/*.pyndarray .
+    cp -v ../$model_object/class_names.json .
+
+    python3 -m fashion_mnist.image_classifier \
+        predict \
+        --data_path $abcli_object_root/$data_object \
+        --model_path $abcli_object_root/$model_object \
+        --output_path $abcli_object_path \
+        ${@:4}
+}
+
+function abcli_image_classifier_train() {
+    local data_object=$(abcli_clarify_object "$1" $abcli_object_name)
+
+    abcli_download $data_object
+
+    local options=$2
+    local do_validate=$(abcli_option_int "$options" "validate" 0)
+
+    local extra_args=""
+    if [ "$do_validate" == true ] ; then
+        local extra_args="--epochs 2"
+    fi
+
+    python3 -m fashion_mnist.image_classifier \
+        train \
+        --color 1 \
+        --data_path $abcli_object_root/$data_object \
+        --model_path $abcli_object_path \
+        $extra_args \
+        ${@:3}
+}

fashion_mnist/__init__.py

@@ -1,5 +1,5 @@
 name = "fashion_mnist"
 
-version = "1.1.22"
+version = "1.1.25"
 
 description = "fashion-mnist + hugging-face + awesome-bash-cli"

fashion_mnist/image_classifier/__init__.py

@@ -0,0 +1,3 @@
+from .. import name as parent_name
+
+name = f"{parent_name}.image_classifier"

fashion_mnist/image_classifier/__main__.py

@@ -0,0 +1,197 @@
+import argparse
+import cv2
+from functools import reduce
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import os.path
+import tensorflow as tf
+from tqdm import *
+import re
+import time
+from . import *
+from abcli import objects
+from abcli import cache
+from abcli import file
+from abcli.tasks import host
+from abcli import graphics
+from abcli.options import Options
+from abcli import path
+from abcli.storage import instance as storage
+from abcli import string
+from abcli.plugins import tags
+
+import abcli.logging
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+parser = argparse.ArgumentParser(name)
+parser.add_argument(
+    "task",
+    type=str,
+    default="",
+    help="describe,eval,ingest,predict,preprocess,train",
+)
+parser.add_argument(
+    "--objects",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--color",
+    type=int,
+    default=0,
+    help="0/1",
+)
+parser.add_argument(
+    "--convnet",
+    type=int,
+    default=1,
+    help="0/1",
+)
+parser.add_argument(
+    "--count",
+    type=int,
+    default=-1,
+)
+parser.add_argument(
+    "--data_path",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--epochs",
+    default=10,
+    type=int,
+    help="",
+)
+parser.add_argument(
+    "--exclude",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--include",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--infer_annotation",
+    type=int,
+    default=1,
+    help="0/1",
+)
+parser.add_argument(
+    "--input_path",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--model_path",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--negative",
+    type=int,
+    default=0,
+    help="0/1",
+)
+parser.add_argument(
+    "--non_empty",
+    type=int,
+    default=0,
+    help="0/1",
+)
+parser.add_argument(
+    "--output_path",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--positive",
+    type=int,
+    default=0,
+    help="0/1",
+)
+parser.add_argument(
+    "--purpose",
+    type=str,
+    default="",
+    help="predict/train",
+)
+parser.add_argument(
+    "--test_size",
+    type=float,
+    default=1.0 / 6,
+)
+parser.add_argument(
+    "--window_size",
+    type=int,
+    default=28,
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "describe":
+    image_classifier().load(args.model_path)
+    success = True
+elif args.task == "eval":
+    success = eval(args.input_path, args.output_path)
+elif args.task == "ingest":
+    success = ingest(
+        args.include,
+        args.output_path,
+        {
+            "count": args.count,
+            "exclude": args.exclude,
+            "negative": args.negative,
+            "non_empty": args.non_empty,
+            "positive": args.positive,
+            "test_size": args.test_size,
+        },
+    )
+elif args.task == "predict":
+    classifier = image_classifier()
+
+    if classifier.load(args.model_path):
+        success, test_images = file.load(
+            "{}/test_images.pyndarray".format(args.data_path)
+        )
+
+    if success:
+        logger.info("test_images: {}".format(string.pretty_size_of_matrix(test_images)))
+
+        _, test_labels = file.load(
+            "{}/test_labels.pyndarray".format(args.data_path),
+            civilized=True,
+            default=None,
+        )
+
+        test_images = test_images / 255.0
+
+        success = classifier.predict(test_images, test_labels, args.output_path)
+elif args.task == "preprocess":
+    success = preprocess(
+        args.output_path,
+        {
+            "objects": args.objects,
+            "infer_annotation": args.infer_annotation,
+            "purpose": args.purpose,
+            "window_size": args.window_size,
+        },
+    )
+elif args.task == "train":
+    classifier = image_classifier()
+    success = classifier.train(
+        args.data_path,
+        args.model_path,
+        {"color": args.color, "convnet": args.convnet, "epochs": args.epochs},
+    )
+else:
+    logger.error(f"-{name}: {args.task}: command not found.")
+
+if not success:
+    logger.error(f"-{name}: {args.task}: failed.")

fashion_mnist/image_classifier/classes.py

@@ -0,0 +1,425 @@
+from .plot import *
+from abcli import file
+from abcli import string
+import numpy as np
+import matplotlib.pyplot as plt
+import abcli.logging
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Image_Classifier(object):
+    def __init__(self):
+        self.class_names = []
+        self.model = None
+        self.params = {"convnet": False}
+
+        self.object_name = ""
+        self.model_size = ""
+
+    def load(self, model_path):
+        success, self.class_names = file.load_json(f"{model_path}/class_names.json")
+        if not success:
+            return False
+
+        success, self.params = file.load_json(f"{model_path}/params.json", default={})
+        if not success:
+            return False
+
+        self.model_size = file.size(f"{model_path}/image_classifier/model")
+
+        try:
+            self.model = tf.keras.models.load_model(
+                f"{model_path}/image_classifier/model"
+            )
+        except:
+            from abcli.logging import crash_report
+
+            crash_report("image_classifier.load({}) failed".format(model_path))
+            return False
+
+        self.window_size = int(
+            cache.read("{}.window_size".format(path.name(model_path)))
+        )
+
+        logger.info(
+            "{}.load({}x{}:{}): {}{} class(es): {}".format(
+                self.__class__.__name__,
+                self.window_size,
+                self.window_size,
+                path.name(model_path),
+                "convnet - " if self.params["convnet"] else "",
+                len(self.class_names),
+                ",".join(self.class_names),
+            )
+        )
+        self.model.summary()
+
+        self.object_name = path.name(model_path)
+
+        return True
+
+    def predict(self, test_images, test_labels, output_path="", options=""):
+        options = Options(options).default("cache", False).default("page_count", -1)
+
+        logger.info(
+            "image_classifier.predict({},{}){}".format(
+                string.pretty_size_of_matrix(test_images),
+                string.pretty_size_of_matrix(test_labels),
+                "-> {}".format(output_path) if output_path else "",
+            )
+        )
+
+        prediction_time = time.time()
+        predictions = self.model.predict(test_images)
+        prediction_time = (time.time() - prediction_time) / test_images.shape[0]
+        logger.info(
+            "image_classifier.predict(): {} / frame".format(
+                string.pretty_duration(prediction_time, include_ms=True)
+            )
+        )
+
+        if not output_path:
+            return True
+
+        if not file.save("{}/predictions.pyndarray".format(output_path), predictions):
+            return False
+
+        if test_labels is not None:
+            from sklearn.metrics import confusion_matrix
+
+            logger.info("image_classifier.predict(): rendering confusion_matrix...")
+
+            cm = confusion_matrix(
+                test_labels,
+                np.argmax(predictions, axis=1),
+                labels=range(len(self.class_names)),
+                # normalize="true",
+            )
+            cm = cm / np.sum(cm, axis=1)[:, np.newaxis]
+            logger.debug("confusion_matrix: {}".format(cm))
+
+            if options["cache"]:
+                if not cache.write("{}.confusion_matrix".format(self.object_name), cm):
+                    return False
+
+            if not file.save("{}/confusion_matrix.pyndarray".format(output_path), cm):
+                return False
+
+            if not graphics.render_confusion_matrix(
+                cm,
+                self.class_names,
+                "{}/Data/0/info.jpg".format(output_path),
+                {
+                    "header": [
+                        " | ".join(host.signature()),
+                        " | ".join(objects.signature()),
+                    ],
+                    "footer": self.signature(prediction_time),
+                },
+            ):
+                return False
+
+        if test_labels is not None:
+            logger.info(
+                "image_classifier.predict(): rendering test_labels distribution..."
+            )
+
+            # accepting the risk that if test_labels does not contain any of the largest index
+            # this function will return False.
+            distribution = np.bincount(test_labels)
+            distribution = distribution / np.sum(distribution)
+
+            if not graphics.render_distribution(
+                distribution,
+                self.class_names,
+                "{}/Data/1/info.jpg".format(output_path),
+                {
+                    "header": [
+                        " | ".join(host.signature()),
+                        " | ".join(objects.signature()),
+                    ],
+                    "footer": self.signature(prediction_time),
+                    "title": "distribution of test_labels",
+                },
+            ):
+                return False
+
+        max_index = test_images.shape[0]
+        if options["page_count"] != -1:
+            max_index = min(24 * options["page_count"], max_index)
+        offset = int(np.max(np.array(objects.list_of_frames(output_path) + [-1]))) + 1
+        logger.info(
+            "image_classifier.predict(offset={}): rendering {} frame(s)...".format(
+                offset, max_index
+            )
+        )
+        for index in tqdm(range(0, max_index, 24)):
+            self.render(
+                predictions[index : index + 24],
+                None if test_labels is None else test_labels[index : index + 24],
+                test_images[index : index + 24],
+                "{}/Data/{}/info.jpg".format(output_path, int(index / 24) + offset),
+                prediction_time,
+            )
+
+        return True
+
+    def predict_frame(self, frame):
+        prediction_time = time.time()
+        try:
+            prediction = self.model.predict(
+                np.expand_dims(
+                    cv2.resize(frame, (self.window_size, self.window_size)) / 255.0,
+                    axis=0,
+                )
+            )
+        except:
+            from abcli.logging import crash_report
+
+            crash_report("image_classifier.predict_frame() crashed.")
+            return False, -1
+
+        prediction_time = time.time() - prediction_time
+
+        output = np.argmax(prediction)
+
+        logger.info(
+            "image_classifier.prediction: [{}] -> {} - took {}".format(
+                ",".join(
+                    [
+                        "{}:{:.2f}".format(class_name, value)
+                        for class_name, value in zip(self.class_names, prediction[0])
+                    ]
+                ),
+                self.class_names[output],
+                string.pretty_duration(
+                    prediction_time,
+                    include_ms=True,
+                    short=True,
+                ),
+            )
+        )
+
+        return True, output
+
+    def render(
+        self,
+        predictions,
+        test_labels,
+        test_images,
+        output_filename="",
+        prediction_time=0,
+    ):
+        num_rows = 4
+        num_cols = 6
+        num_images = num_rows * num_cols
+        plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
+        for i in range(min(num_images, len(predictions))):
+            plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
+            plot_image(i, predictions[i], test_labels, test_images, self.class_names)
+            plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
+            plot_value_array(i, predictions[i], test_labels)
+            plt.tight_layout()
+
+        if output_filename:
+            filename_ = file.auxiliary("prediction", "png")
+            plt.savefig(filename_)
+            plt.close()
+
+            success, image = file.load_image(filename_)
+            if success:
+                image = graphics.add_signature(
+                    image,
+                    [" | ".join(host.signature()), " | ".join(objects.signature())],
+                    self.signature(prediction_time),
+                )
+                file.save_image(output_filename, image)
+
+    def save(self, model_path):
+        model_filename = "{}/image_classifier/model".format(model_path)
+        file.prepare_for_saving(model_filename)
+        try:
+            self.model.save(model_filename)
+            logger.info("image_classifier.model -> {}".format(model_filename))
+        except:
+            from abcli.logging import crash_report
+
+            crash_report("image_classifier.save({}) failed".format(model_path))
+            return False
+
+        self.object_name = path.name(model_path)
+
+        self.model_size = file.size("{}/image_classifier/model".format(model_path))
+
+        if not file.save_json(
+            "{}/class_names.json".format(model_path), self.class_names
+        ):
+            return False
+
+        if not file.save_json("{}/params.json".format(model_path), self.params):
+            return False
+
+        return True
+
+    def signature(self, prediction_time):
+        return [
+            " | ".join(
+                [
+                    "image_classifier",
+                    self.object_name,
+                    string.pretty_bytes(self.model_size) if self.model_size else "",
+                    string.pretty_size(self.input_shape),
+                    "/".join(string.shorten(self.class_names)),
+                    "took {} / frame".format(
+                        string.pretty_duration(
+                            prediction_time,
+                            include_ms=True,
+                            longest=True,
+                            short=True,
+                        )
+                    ),
+                ]
+            )
+        ]
+
+    @staticmethod
+    def train(data_path, model_path, options=""):
+        options = (
+            Options(options)
+            .default("color", False)
+            .default("convnet", True)
+            .default("epochs", 10)
+        )
+
+        classifier = image_classifier()
+        classifier.params["convnet"] = options["convnet"]
+
+        logger.info(
+            "image_classifier.train({}) -{}> {}".format(
+                data_path,
+                "convnet-" if classifier.params["convnet"] else "",
+                model_path,
+            )
+        )
+
+        success, train_images = file.load("{}/train_images.pyndarray".format(data_path))
+        if success:
+            success, train_labels = file.load(f"{data_path}/train_labels.pyndarray")
+        if success:
+            success, test_images = file.load(f"{data_path}/test_images.pyndarray")
+        if success:
+            success, test_labels = file.load(f"{data_path}/test_labels.pyndarray")
+        if success:
+            success, classifier.class_names = file.load_json(
+                f"{data_path}/class_names.json"
+            )
+        if not success:
+            return False
+
+        from tensorflow.keras.utils import to_categorical
+
+        train_labels = to_categorical(train_labels)
+        test_labels = to_categorical(test_labels)
+
+        window_size = train_images.shape[1]
+        input_shape = (
+            (window_size, window_size, 3)
+            if options["color"]
+            else (window_size, window_size, 1)
+            if options["convnet"]
+            else (window_size, window_size)
+        )
+        logger.info(f"input_shape:{string.pretty_size(input_shape)}")
+
+        if options["convnet"] and not options["color"]:
+            train_images = np.expand_dims(train_images, axis=3)
+            test_images = np.expand_dims(test_images, axis=3)
+
+        for name, thing in zip(
+            "train_images,train_labels,test_images,test_labels".split(","),
+            [train_images, train_labels, test_images, test_labels],
+        ):
+            logger.info("{}: {}".format(name, string.pretty_size_of_matrix(thing)))
+        logger.info(
+            "{} class(es): {}".format(
+                len(classifier.class_names), classifier.class_names
+            )
+        )
+
+        train_images = train_images / 255.0
+        test_images = test_images / 255.0
+
+        if options["convnet"]:
+            # https://medium.com/swlh/convolutional-neural-networks-for-multiclass-image-classification-a-beginners-guide-to-6dbc09fabbd
+            classifier.model = tf.keras.Sequential(
+                [
+                    tf.keras.layers.Conv2D(
+                        filters=48,
+                        kernel_size=3,
+                        activation="relu",
+                        input_shape=input_shape,
+                    ),
+                    tf.keras.layers.MaxPool2D(pool_size=2, strides=2),
+                    tf.keras.layers.Conv2D(
+                        filters=48, kernel_size=3, activation="relu"
+                    ),
+                    tf.keras.layers.MaxPool2D(pool_size=2, strides=2),
+                    tf.keras.layers.Conv2D(
+                        filters=32, kernel_size=3, activation="relu"
+                    ),
+                    tf.keras.layers.MaxPool2D(pool_size=2, strides=2),
+                    tf.keras.layers.Flatten(),
+                    tf.keras.layers.Dense(128, activation="relu"),
+                    tf.keras.layers.Dense(64, activation="relu"),
+                    tf.keras.layers.Dense(len(classifier.class_names)),
+                    tf.keras.layers.Activation("softmax"),
+                ]
+            )
+        else:
+            # https://github.com/gato/tensor-on-pi/blob/master/Convolutional%20Neural%20Network%20digit%20predictor.ipynb
+            classifier.model = tf.keras.Sequential(
+                [
+                    tf.keras.layers.Flatten(input_shape=input_shape),
+                    tf.keras.layers.Dense(128, activation="relu"),
+                    tf.keras.layers.Dense(len(classifier.class_names)),
+                    tf.keras.layers.Activation("softmax"),
+                ]
+            )
+
+        classifier.model.summary()
+
+        classifier.model.compile(
+            optimizer="adam",
+            loss=tf.keras.losses.categorical_crossentropy,
+            metrics=["accuracy"],
+        )
+
+        classifier.model.fit(train_images, train_labels, epochs=options["epochs"])
+
+        test_accuracy = float(
+            classifier.model.evaluate(test_images, test_labels, verbose=2)[1]
+        )
+        logger.info("test accuracy: {:.4f}".format(test_accuracy))
+
+        if not file.save_json(
+            f"{model_path}/eval.json",
+            {"metrics": {"test_accuracy": test_accuracy}},
+        ):
+            return False
+
+        if not classifier.save(model_path):
+            return False
+
+        return classifier.predict(
+            test_images,
+            np.argmax(test_labels, axis=1),
+            model_path,
+            cache=True,
+            page_count=10,
+        )
+
+    @property
+    def input_shape(self):
+        return self.model.layers[0].input_shape[1:] if self.model.layers else []

fashion_mnist/image_classifier/funcs.py

@@ -0,0 +1,194 @@
+from . import *
+from abcli import file
+from abcli import string
+import cv2
+import numpy as np
+import os.path
+import abcli.logging
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def eval(input_path, output_path):
+    from sklearn.metrics import accuracy_score
+
+    report = {"accuracy": None}
+
+    success, ground_truth = file.load(f"{input_path}/test_labels.pyndarray")
+    if success:
+        logger.info(
+            "groundtruth: {} - {}".format(
+                string.pretty_size_of_matrix(ground_truth),
+                ",".join([str(value) for value in ground_truth[:10]] + ["..."]),
+            )
+        )
+        success, predictions = file.load(f"{input_path}/predictions.pyndarray")
+
+    if success:
+        predictions = np.argmax(predictions, axis=1).astype(np.uint8)
+        logger.info(
+            "predictions: {} - {}".format(
+                string.pretty_size_of_matrix(predictions),
+                ",".join([str(value) for value in predictions[:10]] + ["..."]),
+            )
+        )
+
+        report["accuracy"] = accuracy_score(predictions, ground_truth)
+
+        logger.info(
+            "image_classifier.eval({}->{}): {:.2f}%".format(
+                input_path, output_path, 100 * report["accuracy"]
+            )
+        )
+
+    return file.save_json(os.path.join(output_path, "evaluation_report.json"), report)
+
+
+def preprocess(
+    output_path,
+    objects="",
+    infer_annotation=True,
+    purpose="predict",
+    test_size=1.0 / 6,
+    window_size=28,
+):
+    if objects:
+        logger.info(
+            "image_classifier.preprocess({}{})->{} - {}x{} - for {}".format(
+                ",".join(objects),
+                " + annotation" if infer_annotation else "",
+                output_path,
+                window_size,
+                window_size,
+                purpose,
+            )
+        )
+
+        annotations = []
+        list_of_images = []
+        for index, object in enumerate(objects):
+            list_of_images_ = [
+                "{}/Data/{}/camera.jpg".format(object, frame)
+                for frame in objects.list_of_frames(object)
+            ]
+
+            annotations += len(list_of_images_) * [index]
+            list_of_images += list_of_images_
+
+        annotations = np.array(annotations) if infer_annotation else []
+    else:
+        logger.info(
+            "image_classifier.preprocess({}) - {}x{} - for {}".format(
+                output_path,
+                window_size,
+                window_size,
+                purpose,
+            )
+        )
+
+        list_of_images = [
+            "{}/Data/{}/camera.jpg".format(output_path, frame)
+            for frame in objects.list_of_frames(output_path)
+        ]
+
+        annotations = np.array(
+            file.load_json(
+                f"{output_path}/annotations.json".format(),
+                civilized=True,
+                default=None,
+            )[1]
+        ).astype(np.uint8)
+
+    if len(annotations) and len(list_of_images) != len(annotations):
+        logger.error(
+            f"-{name}: preprocess: mismatch between frame and annotation counts: {len(list_of_images):,g} != {len(annotations):,g}"
+        )
+        return False
+    logger.info("{:,} frame(s)".format(len(list_of_images)))
+
+    tensor = np.zeros(
+        (len(list_of_images), window_size, window_size, 3),
+        dtype=np.uint8,
+    )
+
+    error_count = 0
+    for index, filename in enumerate(list_of_images):
+        logger.info("+= {}".format(filename))
+        success_, image = file.load_image(filename)
+        if success_:
+            try:
+                tensor[index, :, :, :] = cv2.resize(image, (window_size, window_size))
+            except:
+                from abcli.logging import crash_report
+
+                crash_report("image_classifier.preprocess() failed")
+                success_ = False
+
+        if not success_:
+            error_count += 1
+    logger.info(
+        "tensor: {}{}".format(
+            string.pretty_size_of_matrix(tensor),
+            " {} error(s)".format(error_count) if error_count else "",
+        )
+    )
+
+    success = False
+    if purpose == "predict":
+        if not file.save("{}/test_images.pyndarray".format(output_path), tensor):
+            return False
+        if len(annotations):
+            if not file.save(
+                "{}/test_labels.pyndarray".format(output_path), annotations
+            ):
+                return False
+        success = True
+    elif purpose == "train":
+        if not len(annotations):
+            logger.error(f"-{name}: preprocess: annotations are not provided.")
+            return False
+
+        from sklearn.model_selection import train_test_split
+
+        (
+            tensor_train,
+            tensor_test,
+            annotations_train,
+            annotations_test,
+        ) = train_test_split(tensor, annotations, test_size=test_size)
+        logger.info(
+            "test-train split: {:.0f}%-{:.0f}% ".format(
+                len(annotations_test) / len(annotations) * 100,
+                len(annotations_train) / len(annotations) * 100,
+            )
+        )
+        logger.info(
+            "tensor_train: {}".format(string.pretty_size_of_matrix(tensor_train))
+        )
+        logger.info("tensor_test: {}".format(string.pretty_size_of_matrix(tensor_test)))
+        logger.info(
+            "annotations_train: {}".format(
+                string.pretty_size_of_matrix(annotations_train)
+            )
+        )
+        logger.info(
+            "annotations_test: {}".format(
+                string.pretty_size_of_matrix(annotations_test)
+            )
+        )
+
+        success = (
+            file.save("{}/train_images.pyndarray".format(output_path), tensor_train)
+            and file.save("{}/test_images.pyndarray".format(output_path), tensor_test)
+            and file.save(
+                "{}/train_labels.pyndarray".format(output_path), annotations_train
+            )
+            and file.save(
+                "{}/test_labels.pyndarray".format(output_path), annotations_test
+            )
+        )
+    else:
+        logger.error(f"-{name}: preprocess: {purpose}: purpose not found.")
+
+    return success

fashion_mnist/image_classifier/plot.py

@@ -0,0 +1,48 @@
+from abcli import string
+import matplotlib.pyplot as plt
+import numpy as np
+import abcli.logging
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def plot_image(i, predictions_array, true_label, image, class_names):
+    plt.grid(False)
+    plt.xticks([])
+    plt.yticks([])
+
+    plt.imshow(image[i], cmap=plt.cm.binary)
+
+    predicted_label = np.argmax(predictions_array)
+
+    if true_label is None:
+        color = "black"
+    elif predicted_label == true_label[i]:
+        color = "blue"
+    else:
+        color = "red"
+
+    plt.xlabel(
+        "{} {:2.0f}%{}".format(
+            string.shorten(class_names[predicted_label]),
+            100 * np.max(predictions_array),
+            ""
+            if true_label is None
+            else " ({})".format(string.shorten(class_names[true_label[i]])),
+        ),
+        color=color,
+    )
+
+
+def plot_value_array(i, predictions_array, true_label):
+    plt.grid(False)
+    plt.xticks(range(len(predictions_array)))
+    plt.yticks([])
+    handle = plt.bar(range(len(predictions_array)), predictions_array, color="#777777")
+    plt.ylim([0, 1])
+    predicted_label = np.argmax(predictions_array)
+
+    handle[predicted_label].set_color("green")
+    if true_label is not None:
+        handle[true_label[i]].set_color("blue")