Машинно обучение за прогнозиране на малария: Създаване на уеб приложение с JavaScript

Маларията е векторно заболяване, причинено от протозои. Болестта се предава чрез ухапване от комар, което причинява малко по-малко от милион смъртни случая годишно. Ранното откриване и правилното лечение са от решаващо значение за борбата с този проблем за общественото здраве.

Използването на машинно обучение за прогнозиране на малария показа обещаващи резултати. В тази статия ще се съсредоточим конкретно върху използването на изображения на тънки кръвни петна за изграждане на модел за машинно обучение с помощта на tensorFlow. Ще интегрираме този модел с уеб приложение, използвайки стека MERN. Нашата цел е да предоставим по-добро разбиране за това как машинното обучение може да се приложи към проблеми от реалния свят.

Включих връзка към моя примерен сайт по-долу за ваша справка:

[ЗАБЕЛЕЖКА]: Сайтът може да не работи за голяма част от месеца, тъй като използвам безплатна услуга за внедряването му. Ако не работи, можете да се обърнете към моя Github в края на тази статия

Данните:

Нашият набор от данни се състои от 13780 изображения на заразени пациенти и 13780 изображения на здрави пациенти с различни размери, които изискват предварителна обработка, преди да бъдат подавани към модела. Наборът от данни е свързан по-долу.

Предварителни условия:

Цялата работа можете да намерите на следната връзка.

https://colab.research.google.com/drive/1dXJZKB0rM-4Dngd6rKRoRvDlwMaAPaiN?usp=sharing

Първо, всички предварителни модели като tensorflow, tensorflowjs, numpy, pandas, cv2 се импортират.

!pip install kaggle
!pip install tensorflowjs
!pip3 install --upgrade tensorflow==2.11.0
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import tensorflow as tf #machine-learning module
import tensorflowjs as tfjs #used to convert model to a format usable in node js
import cv2 #image I/O
import matplotlib.pyplot as plt #plotting 
import seaborn as sns #plotting
from PIL import Image #Used to read Image

Увеличаване и нормализиране на данни:

Настройваме средата и изтегляме набора от данни.

За частта за предварителна обработка преоразмеряваме всички изображения до 50x50 и качваме 2 варианта: 1.0оригинал

2. Завъртяно на 45

3. Завъртяно на 75

4. Замъглено изображение

Това се прави, за да се предостави на модела широк набор от входни данни, ние също така включваме кръвни натривки от неинфектирани пациенти.

data = []
labels = []

for i in infected:
      image = cv2.imread("/content/cell_images/Parasitized/"+i)
      image_array = Image.fromarray(image , 'RGB')
      resize_img = image_array.resize((50 , 50))
      rotated45 = resize_img.rotate(45)
      rotated75 = resize_img.rotate(75)
      blur = cv2.blur(np.array(resize_img) ,(10,10))
      data.append([np.array(resize_img) , np.array(rotated45) , np.array(rotated75) , np.array(blur)])
      labels.append([1,1,1,1])

След това нормализираме входа, така че всички стойности да са между 0 и 1.

Това се прави чрез разделяне на стойностите на пикселите на 255. Не забравяйте тази важна стъпка.

cells = cells/255

Моделът:

Ще използваме конволюционна невронна мрежа (CNN) за идентификация на изображения. Нашият набор от данни ще бъде разделен на подгрупи за обучение и тестване в съотношение 0,8.

След като слоевете на мрежата са дефинирани и компилирани, ще продължим да подаваме данните за обучение.

model = keras.Sequential([
    keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(50, 50, 3)),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Conv2D(64, (3, 3), activation='relu'),
    keras.layers.MaxPooling2D((2, 2)),
    keras.layers.Flatten(),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(1,activation='sigmoid')
])

model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

Започнете да обучавате модела. Колкото по-голям е броят на епохите, толкова по-добра е точността. Можете да проверите показателите на модела.

from sklearn.metrics import accuracy_score,precision_score,confusion_matrix
history = model.fit(train_x, train_y, epochs=10, validation_data=(test_x, test_y))
test_loss, test_acc = model.evaluate(test_x, test_y, verbose=2)
predictions = model.predict(test_x)
predictions = (predictions >= 0.5).astype(int)
cm = confusion_matrix(test_y, predictions)
cm
accuracy_score(test_y,predictions)
precision_score(test_y,predictions
Epoch 1/5
905/905 [==============================] - 25s 14ms/step - loss: 0.5036 - accuracy: 0.7383 - val_loss: 0.3082 - val_accuracy: 0.9020
Epoch 2/5
905/905 [==============================] - 9s 10ms/step - loss: 0.2088 - accuracy: 0.9192 - val_loss: 0.1709 - val_accuracy: 0.9374
Epoch 3/5
905/905 [==============================] - 10s 11ms/step - loss: 0.1579 - accuracy: 0.9444 - val_loss: 0.1380 - val_accuracy: 0.9561
Epoch 4/5
905/905 [==============================] - 11s 13ms/step - loss: 0.1306 - accuracy: 0.9562 - val_loss: 0.1239 - val_accuracy: 0.9603
Epoch 5/5
905/905 [==============================] - 10s 11ms/step - loss: 0.1161 - accuracy: 0.9605 - val_loss: 0.1164 - val_accuracy: 0.9627
1055/1055 [==============================] - 2s 2ms/step

#Confusion matrix
array([[14047,   451],
       [  808, 18453]])

#Accuracy
0.9627062412986167

#Precision
0.9761426153195091

Моделът е с точност 96.2% и 97.6% сточност. Основната истина може да се види от:

plt.figure(1 , figsize = (15 , 9))
n = 0 
for i in range(49):
    n += 1 
    r = np.random.randint( 0  , test_x.shape[0] , 1)
    plt.subplot(7 , 7 , n)
    plt.subplots_adjust(hspace = 0.5 , wspace = 0.5)
    plt.imshow(test_x[r[0]])
    plt.title('true {} : pred {}'.format(test_y[r[0]] , predictions[r[0]]) )
    plt.xticks([]) , plt.yticks([])

plt.show()kak

Сега можете да запишете модела като файл с разширение .h5 или да го запишете като json файл с плаващи тегла, съхранени в отделен bin файл. Избрах да го запазя като json файл.

#.h5 file
model.save('path/to/model/save/file')

#json and bin file
tfjs.converters.save_keras_model(model,'/path/to/model/folder')

Интеграцията:

Сега ще интегрираме модела в среда на JavaScript. Следният код е изцяло в JavaScript.

Първо ще получим изображението от потребителя от предния край и ще го изпратим на сървъра.

<input type="file" className="form-control" id="image" onChange={handleImageChange} />
<button className="btn btn-primary" onClick={handleSubmit}>Upload</button>

#functions
  const handleImageChange = (e) => {
    setImageUrl(URL.createObjectURL(e.target.files[0]));
  };

    const handleSubmit = (e) => { e.preventDefault();
    const formData = new FormData();
    formData.append("image", selectedImage);
    fetch("api_url", {method: "POST",body: formData})

Предполагам, че вече знаете как да настроите основен експресен сървър. Трябва да инсталирате multer, sharp и tenserflowjs за прогнозиране. Имах проблеми с инсталирането на последния, така че не забравяйте да инсталирате:

Python

https://www.python.org/downloads/

Visual Studio (разработка с C++)

npm i multer sharp @tensorflow/tfjs-node

В задната част ще импортираме гореспоменатите js модули и ще зададем пътя на файла на model.json

Уверете се, че файлът model.son и файлът bin, съдържащ теглата, са в една и съща папка. Пътят на файла трябва да бъде пълният път в Unix стил

const sharp = require('sharp');
const multer = require('multer');
const tf = require('@tensorflow/tfjs-node');

Сега ще настроим multer да обработва входящото изображение, така че да може да бъде преоразмерено и преоформено, за да съответства на входната форма на модела. Зададохме ограничението за размер на изображението да бъде 10Mb и приемаме само jpegs и pngs. Персонализирайте този код, за да приема други формати. Това се прави от:

const upload = multer({
    storage: multer.diskStorage({
        destination: function (req, file, cb) { cb(null, './uploads/') },
        filename: function (req, file, cb) { cb(null, file.originalname) }
    }),
    limits: { fileSize: 1024 * 1024 * 10 },
    fileFilter: function (req, file, cb) {
        if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') cb(null, true);
        else cb(new Error('Invalid file type'));
    }
});

Сега идва пикантната част. Ние прогнозираме дали кръвта е паразатизирана или не. Изображението се преоразмерява и декодира в тензор и се преоформя. След това се въвежда в модела, за да се предвиди стойност между 0 и 1. Избира се праг за класифициране на изображението

app.post('/api/malaria', upload.single('image'), async (req, res) => {
  sharp(req.file.path).resize(50, 50).toBuffer()
  .then((data) => {
    const tensor = tf.node.decodeImage(data, 3);
    let reshapedTensor = tensor.reshape([1, 50, 50, 3]).div(255);
    model.then(mod => {
      let ans = mod.predict(reshapedTensor).dataSync()[0];
      res.json({prediction:ans});}
    }
}

И това е. Създадохте модел и го интегрирахте в JS екосистема!

Тук стойностите се извличат от сървъра и се показват на потребителя. Също така се опитваме да получим правилния етикет, за да подобрим допълнително модела.

Ето връзката към моя профил в Github. Можете да се обърнете към предния и задния край на хранилищата. Можете също така да разгледате моите други проекти, като програмата за плочки за пиано, която чупи световен рекорд!

Джаянт Бонта

Това е направено под ръководството на Dr. Девикаруби Раджасекаран в мемориалния технологичен институт Кешав