Android上で実行する転移学習実装方法(by Kotlin)

    /**
     * サンプルデータ追加
     */
    suspend fun addSample(
        image: Array<Array<FloatArray>>,
        className: String,
    ) = withContext(Dispatchers.Default) {
        classIndexes
            .takeIf { it.containsKey(className) }
            ?: throw IllegalArgumentException("Class $className is not one of the classes recognized by the model")

        oneHotEncodedClass[className]?.let {
            val bottleneck = model.loadBottleneck(image)
            trainingSamples = trainingSamples + TrainingSample(bottleneck, it)
        }
            ?: throw IllegalArgumentException("Class $className is not one of the oneHotEncodedClass")
    }

学習

        withContext(Dispatchers.Default) {
            // エポック数分実行する
            (0..numEpochs).forEach { epoch ->
                var totalLoss = 0.0f
                var numBatchesProcessed = 0

                // バッチ単位で取得できるようWrapperクラスを利用する
                val trainingSamples =
                    TrainingSamples(
                        data = trainingSamples,
                        trainBatchSize = trainBatchSize,
                    )

                // バッチ単位の学習データがある分だけ実行する
                while (trainingSamples.hasNext()) {

                    val batch = trainingSamples.next()

                    // 学習データ一つずつを詰めていく
                    batch.forEachIndexed { i, sample ->
                        trainingBatchBottlenecks[i] = sample.bottleneck
                        trainingBatchLabels[i] = sample.label
                    }

                    val loss: Float =
                        model.runTraining(trainingBatchBottlenecks, trainingBatchLabels)

                    totalLoss += loss
                    numBatchesProcessed++
                }

                val avgLoss = totalLoss / numBatchesProcessed
                lossConsumer.onLoss(epoch, avgLoss)
                Log.d("$epoch all End" , "DEBUG")
            }

参考：コード全体

class TransferLearningModel(
    modelLoader: ModelLoader,
    private var classes: Collection<String>,
    private var classNum: Int = 4,
) : Closeable {

    data class Prediction(
        val className: String,
        val confidence: Float,
    )

    data class TrainingSample (
        var bottleneck: FloatArray,
        var label: FloatArray,
    )

    class TrainingSamples constructor(
        private var nextIndex: Int = 0,
        private var trainBatchSize: Int,
        private var data: List<TrainingSample>,
    ) {
        init {
            data = data.shuffled()
        }

        fun hasNext(): Boolean {
            return nextIndex < data.size
        }

        fun next(): List<TrainingSample> {
            val fromIndex = nextIndex
            val toIndex =
                (nextIndex + trainBatchSize)
                    .also {
                        nextIndex = it
                    }

            if (toIndex >= data.size) {
                return data.subList(
                    data.size - trainBatchSize, data.size
                )
            }
            return data.subList(fromIndex, toIndex)
        }
    }

    interface LossConsumer {
        fun onLoss(epoch: Int, loss: Float)
    }

    private var model: LiteMultipleSignatureModel

    private val classIndexes = TreeMap<String, Int>() // {className to Index}
    private val oneHotEncodedClass =
        mutableMapOf<String, FloatArray>() // {className, Array(該当Classのみ１，その他0)}

    private var trainingSamples: List<TrainingSample> = mutableListOf()

    init {
        // model load
        model =
            runCatching {
                LiteMultipleSignatureModel(
                    modelLoader.loadMappedFile(MODEL_FILE_NAME),
                    classes.size,
                )
            }.getOrNull()
                ?: throw RuntimeException("Couldn't read underlying model for TransferLearningModel")

        // classesをone hotエンコーディングに変更
        classes.forEachIndexed { index, s ->
            classIndexes[s] = index
            oneHotEncodedClass[s] = oneHotEncoding(index)
        }
    }

    /**
     * サンプルデータ追加
     */
    suspend fun addSample(
        image: Array<Array<FloatArray>>,
        className: String,
    ) = withContext(Dispatchers.Default) {
        classIndexes
            .takeIf { it.containsKey(className) }
            ?: throw IllegalArgumentException("Class $className is not one of the classes recognized by the model")

        oneHotEncodedClass[className]?.let {
            val bottleneck = model.loadBottleneck(image)
            trainingSamples = trainingSamples + TrainingSample(bottleneck, it)
        }
            ?: throw IllegalArgumentException("Class $className is not one of the oneHotEncodedClass")
    }

    suspend fun train(
        numEpochs: Int = 1,
        lossConsumer: LossConsumer
    ) {
        // batch size は最低1とする
        val trainBatchSize =
            getTrainBatchSize()
                .also {
                    if (trainingSamples.size < it) {
                        throw java.lang.RuntimeException("Too few samples to start training: need $it, got $trainingSamples.size")
                    }
                }

        // 学習に必要なボトルネック特徴量とラベルを取得する
        val trainingBatchBottlenecks =
            Array(trainBatchSize) { FloatArray(model.getNumBottleneckFeatures()) }
        val trainingBatchLabels = Array(trainBatchSize) { FloatArray(classIndexes.size) }

        withContext(Dispatchers.Default) {
            // エポック数分実行する
            (0..numEpochs).forEach { epoch ->
                var totalLoss = 0.0f
                var numBatchesProcessed = 0

                // バッチ単位で取得できるようWrapperクラスを利用する
                val trainingSamples =
                    TrainingSamples(
                        data = trainingSamples,
                        trainBatchSize = trainBatchSize,
                    )

                // バッチ単位の学習データがある分だけ実行する
                while (trainingSamples.hasNext()) {

                    val batch = trainingSamples.next()

                    // 学習データ一つずつを詰めていく
                    batch.forEachIndexed { i, sample ->
                        trainingBatchBottlenecks[i] = sample.bottleneck
                        trainingBatchLabels[i] = sample.label
                    }

                    Log.d("$epoch training Start" , "DEBUG")
                    val loss: Float =
                        model.runTraining(trainingBatchBottlenecks, trainingBatchLabels)
                    Log.d("$epoch training End" , "DEBUG")

                    totalLoss += loss
                    numBatchesProcessed++
                }

                val avgLoss = totalLoss / numBatchesProcessed
                lossConsumer.onLoss(epoch, avgLoss)
                Log.d("$epoch all End" , "DEBUG")
            }
        }
    }

    fun predict(
        image: Array<Array<FloatArray>>
    ): Array<Prediction> {

        /* TODO */
    }

    fun getTrainBatchSize(): Int {
        return minOf(
            maxOf(trainingSamples.size, 1),
            model.getExpectedBatchSize()
        )
    }

    private fun oneHotEncoding(classIdx: Int): FloatArray =
        FloatArray(classNum)
            .apply { this[classIdx] = 1.0f }

    override fun close() {
        model.close()
    }

    companion object {
        private const val MODEL_FILE_NAME = "model.tflite"
    }

Android: 実行

最後に