机器学习项目：使用Keras和tfjs构建血细胞分类模型

from keras.modelsimport Sequential
from keras.layersimport Dense, Conv2D, Dropout, MaxPool2D, Flatten
from keras.preprocessingimport image

generator= image.ImageDataGenerator(
        rescale= 1./255,
        featurewise_center=False, # set input mean to 0 over the dataset
        samplewise_center=False, # set each sample mean to 0
        featurewise_std_normalization=False, # divide inputs by std of the dataset
        samplewise_std_normalization=False, # divide each input by its std
        zca_whitening=False, # apply ZCA whitening
        rotation_range=10, # randomly rotate images in the range (degrees, 0 to 180)
        width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)
        height_shift_range=0.1, # randomly shift images vertically (fraction of total height)
        horizontal_flip=True, # randomly flip images
        vertical_flip=False)

dataset= generator.flow_from_directory（
    shuffle= True，
    batch_size= 32，
    target_size=（
    80,80 ），directory='dataset2-master / images / TRAIN'
）

def model():
    model= Sequential()
    model.add(Conv2D(80, (3,3), strides= (1,1), activation= 'relu'))
    model.add(Conv2D(64, (3,3), strides= (1,1), activation= 'relu', input_shape= (80,80,3)))
    model.add(MaxPool2D(pool_size= (2,2)))
    model.add(Conv2D(64, (3,3), strides= (1,1), activation= 'relu'))
    model.add(Dropout(0.25))
    model.add(Flatten())

    model.add(Dense(128, activation= 'relu'))
    model.add(Dropout(0.5))
    model.add(Dense(4, activation= 'softmax'))

    model.compile(loss= 'categorical_crossentropy', optimizer= 'adadelta', metrics= ['accuracy'])

    return model

nn= model（）
nn.fit_generator（dataset，steps_per_epoch= None，epochs= 30，verbose= 1）
nn.save（'Model.h5'）

npm install-g create-react-app
create-react-app app_name
cd app_name
npm install--save @tensorflow/tfjs
//on server side:
mkdir server
cd server
npm init
//fill up the details, make sure package.jsonis created
npm install express--save

let express= require('express')
let cors= require('cors')
let path= require('path')

var app= express()

let static_path= path.join(__dirname,'ModelData/model_data')

app.use(cors())
app.use(express.static(static_path))

app.get('/model_metadata', (req, resp)=> {
    resp.sendFile(static_path+'/model.json')
})

app.listen(5443, ()=> console.log('Serving tfjs model on express API server'))

$tensorflowjs_converter--input_format keras \
                        Model.h5 \
                        ModelData/model_data
// Model.h5is the downloaded model after training, last argumentis the target folder, where we need to store the model files.

var tensorflow= require('@tensorflow/tfjs')

class ModelContainer {
    constructor(nn){
        this.nn= nn
    }
    setWeights(weights){
        //use json weightsfile
    }
    async loadFromURL(url){
        console.log(url)
        this.nn= await tensorflow.loadModel(url)
        console.log(this.nn)
    }
    removeNetwork(){
        this.nn= null
    }

    swapToNewObject(){
        let new_nn= this.nn
        this.nn= null
        return new_nn
    }

    obtainMemorySafe(){
        return this.swapToNewObject()
    }

    obtain(){
        return this.nn
    }
}



function runInference(modelContainer, imageData){
    //perform a sawp, i.e obtain networkobject from container
    imageData.style.width= "80px";
    imageData.style.height= "80px";
    let nn= modelContainer.obtainMemorySafe()
    let pixels= tensorflow.fromPixels(imageData)
    pixels= pixels.reshape([1,80,80,3])
    pixels.dtype= 'float32'
    pixels= tensorflow.div(pixels,255)
    let predictions= nn.predict(pixels)
    modelContainer.nn= nn
    nn = null
    return predictions.dataSync()
}

function afterPrediction(predictions){
    //as of now
    console.log(predictions)
}

export {ModelContainer, runInference, afterPrediction}

let modelCache= new ModelContainer （null）;
modelCache.loadFromURL（'http://192.168.0.105:5443/model_metadata'）

<div style= {{margin :'40px 40px 40px 40px', textAlign :'center'}}>
                            <button className= "button is-rounded is-danger" onClick= {
                                ()=> {
                                    let result= runInference(modelCache, document.getElementById('image_container'))
                                    this.setState({
                                        scores : this.computeScore(result),
                                        show_result : true
                                    })
                                }
                            }>Predict</button>
</div>

//and computeScore function :
computeScore(predictions) {
       letsum = 0;
       for(var i= 0; i < predictions.length; i++)sum+=predictions[i]

        //cumpute proportions
        let proportions= []
        for(var i= 0; i < predictions.length; i++){
            let prop= (predictions[i]* 100)/sum
            proportions.push(prop)
        }

        return {
            EOSINOPHIL : proportions[0],
            LYMPHOCYTE : proportions[1],
            MONOCYTE : proportions[2],
            NEUTROPHIL : proportions[3]
        }
   }
}