Как использовать обученную модель в python
Перейти к содержимому

Как использовать обученную модель в python

  • автор:

Как использовать обученную модель нейронной сети?

Добрый день! Не могу понять, как использовать уже обученную модель нейронной сети. Программирую на питоне, использую библиотеку keras. Анализирую временные ряды. Нейронная сеть обучена, модель сохранена. Как описано в документации keras, надо вызвать метод model_name.predict(). Хорошо. Делаю так: model.predict(dataset), где dataset — это значения за последние 90 дней. А мне надо получить прогноз вперед на, скажем, 10 дней. Но прогноз делается только для указанного набора данных на 90 дней! То есть можно только сравнить исходные данные и прогнозные. Практического толка никакого. Так как же делать прогноз наперед?

Отслеживать
задан 24 янв 2018 в 11:14
107 11 11 бронзовых знаков

Вам надо скормить модели входные данные за следующие 10 дней. Данные должны быть в нужном формате (такой же как у вашего dataset )

24 янв 2018 в 12:26

MaxU, вы меня не поняли. Стоит задача именно предсказать значения на 10 дней вперед. Сегодня 24 января, мне нужен прогноз по 3 февраля. А метод predict( ), в том то и проблема, можно использовать только при наличии входных данных. Вот как сделать так, чтобы я передал в обученную модель сети данные за последние 90 дней, включая сегодняшний, а она мне предсказала значения на 10 дней с завтрашнего дня?

24 янв 2018 в 14:37
Как выглядит ваш dataset ? Из чего он состоит?
24 янв 2018 в 15:35

по-моему данные за прошедшие 90 дней нужны были только для обучения модели. Для предсказания они не нужны..

24 янв 2018 в 17:49

MaxU, в любом случае спасибо ) Я вчера наткнулся на пример кода, который вроде реализует то, что я хочу. Посмотрим, что он выдает, а там видно будет ))

Предобученные модели

Предобученные модели

С помощью deep learning можно решить многие задачи computer vision — обнаружения и классификации объектов, распознавания лиц, генерации изображений, сегментации.

Обучение модели может занимать от считанных минут до нескольких месяцев (в зависимости от набора данных и конкретной задачи). Из-за значительных вычислительных затрат еще несколько лет назад этим занимались исследовательские университеты и крупные технологические компании. Сейчас нам помогает трансферное обучение.

Трансферное обучение

Трансферное обучение — подраздел ML. Его цель — применение знаний, полученных благодаря решению одной задачи, к другой, но схожей задаче. Это популярный метод компьютерного зрения — он позволяет получить точные модели, экономя время и деньги. При переносе обучения мы начинаем с признаков, усвоенных при решении другой задачи, вместо того чтобы тренировать модели с нуля.

Еще в 2016 году Эндрю Ын спрогнозировал рост популярности метода: «Трансферное обучение будет следующим двигателем коммерческого успеха ML после обучения с учителем».

Предобученные модели: что это и где их искать

Трансферное обучение предполагает использование предобученных моделей (созданных и натренированных на большом наборе общедоступных данных). Чаще всего их разрабатывают крупные технологические компании или ведущие исследователи в области компьютерного зрения. Эти модели обучаются на внушительных объемах данных (например, ImageNet — ~14 млн изображений, Google Landmarks Dataset v2 — ~5 млн изображений).

Выбор предобученной модели зависит от задачи. YOLOv2 используется для обнаружения и классификации объектов, OpenFace — для распознавания лиц, ResNet — для классификации изображений.

Для успешного трансферного обучения нужна модель, натренированная на наборе данных, схожем с целевым. Так, модель, обученная на изображениях лиц, не лучшим образом обобщается для задачи распознавания текста. Поэтому популярны модели, обученные на больших и разнообразных наборах данных (выученные признаки встречаются в других наборах с высокой вероятностью).

Фреймворки машинного обучения — один из источников натренированных моделей. Наборы предобученных моделей предоставляют Tensorflow, PyTorch, Keras, Caffe2. Например:

  • Tensorflow Model Garden — репозиторий с множеством реализаций SOTA-моделей на основе TensorFlow.
  • Модели Torchvision включают основные архитектуры для задачи классификации изображений (AlexNet, VGG, ResNet и другие).
  • Keras applications предоставляет коллекцию популярных моделей для задачи классификации, которые легко подгрузить с помощью оболочки Keras.
  • Caffe и Caffe2 также предоставляют набор готовых предобученных моделей.

курсы по теме:

Data Science with Python

Способы сохранения и загрузки моделей в Keras

Часто спроектированную и обученную модель требуется сохранять для последующего ее использования в прикладных задачах. Либо, еще в процессе обучения создавать контрольные точки на случай возникновения какого-либо сбоя. Могут быть и другие причины, требующие запись данных на носитель и последующего восстановления модели. На этом занятии мы с вами рассмотрим такой базовый функционал пакета Keras.

Для простоты положим, что у нас простая задача классификации изображений цифр последовательной полносвязной сетью:

import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.datasets import mnist tf.random.set_seed(1) (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(-1, 784) / 255.0 x_test = x_test.reshape(-1, 784) / 255.0 y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) model = keras.Sequential([ layers.Dense(128, activation='relu'), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc']) model.fit(x_train, y_train, epochs=5)
  • model.save() или tf.keras.models.save_model() – для записи модели на носитель;
  • keras.models.load_model() – для загрузки модели по указанному пути.
model.save('16_model') model_loaded = keras.models.load_model('16_model')

И, затем, прогнать тестовую выборку через загруженную модель:

model_loaded.evaluate(x_test, y_test)
  • архитектура модели;
  • значения весовых коэффициентов модели;
  • информация о начальной настройки метода compile() (вид оптимизатора, функции потерь и метрик);
  • состояние оптимизатора в момент сохранения модели (для возможности продолжения обучения из текущего состояния).
model.save('16_model_2.h5') model.save('16_model_3', save_format='h5') model_loaded = keras.models.load_model('16_model_2.h5')

Разумеется, рекомендуется использовать новый формат данных при сохранении моделей.

Методы get_config() и from_config()

Остается вопрос, как более детально происходит сохранение и загрузка архитектуры модели? Что конкретно хранится на диске? Согласно документации: https://www.tensorflow.org/guide/keras/save_and_serialize формат SavedModel хранит имя класса, реализацию функцииcall(), потери, веса и значение конфигурации (если в модели реализован метод get_config). Так вот, при отсутствии явного описания конфигурации, реализация функции call() используется для воссоздания работы модели или слоя (если реконструируется отдельный слой). Чтобы все это было понятнее, давайте рассмотрим пример сохранения и загрузки пользовательского класса модели с полносвязными слоями:

class NeuralNetwork(tf.keras.Model): def __init__(self, units): super().__init__() self.units = units self.model_layers = [layers.Dense(n, activation='relu') for n in self.units] def call(self, inputs): x = inputs for layer in self.model_layers: x = layer(x) return x

Мы здесь в конструкторе формируем список полносвязных слоев с функцией активации ReLU, а затем, в методе call() пропускаем входной сигнал последовательно через эти слои. Далее, мы должны воспользоваться этой моделью, чтобы сформировались весовые коэффициенты:

model = NeuralNetwork([128, 10]) y = model.predict(tf.expand_dims(x_test[0], axis=0)) print(y)

И, если теперь выполнить сохранение этой модели:

model.save('16_model')

то в файле saved_model.pb будет храниться реализация метода call(), которая и будет определять структуру модели. Тоесть, послееезагрузки:

model_loaded = keras.models.load_model('16_model')

будет воссоздан класс NeuralNetwork вместе с конкретной реализацией метода call() и теми же самыми весовыми коэффициентами. Именно поэтому, при пропускании того же самого входного сигнала, мы получим абсолютно такие же результаты:

y = model_loaded.predict(tf.expand_dims(x_test[0], axis=0)) print(y)

На первый взгляд эта информация может показаться избыточной. Какая нам разница, как все это в деталях работает, главное, что мы можем сохранять и загружать модели?Однако, существуют ситуации, когда это имеет важное значение. И одну из них я сейчас продемонстрирую. Предположим, что мы бы хотели загрузить модель, но с некоторыми изменениями. Например, вместо функции активации ReLU использовать другую – linear. По идее, для этого можно описать еще один похожий класс модели NeuralNetworkLinear с измененной активационной функцией:

class NeuralNetworkLinear(tf.keras.Model): def __init__(self, units): super().__init__() self.units = units self.model_layers = [layers.Dense(n, activation='linear') for n in self.units] def call(self, inputs): x = inputs for layer in self.model_layers: x = layer(x) return x

А при загрузке указать, чтобы вместо прежнего класса NeuralNetwork был подставлен новый:

model_loaded = keras.models.load_model('16_model', custom_objects={"NeuralNetwork": NeuralNetworkLinear})

Однако, при запуске программы, мы увидим прежний результат, так как через метод call() будут восстановлены исходные полносвязные слоии конструктор класса вызван не будет. Чтобы полноценно использовать новую модель класса NeuralNetworkLinear при загрузке данных, в файл необходимо сохранять конфигурацию модели, а затем, реконструировать ее по этой конфигурации. Для этого в оба класса добавим два специальных метода:

def get_config(self): return {'units': self.units} @classmethod def from_config(cls, config): return cls(**config)
  • Sequential.from_config(config);
  • Model.from_config(config).
config = model.get_config()
  • json_config = model.to_json() – конфигурация архитектуры в формате JSON;
  • new_model = keras.models.model_from_json(json_config) – загрузкаархитектуры модели из JSON-формата.

Методы get_weights(), set_weights() и save_weights(), load_weights()

  • get_weights() – получение коэффициентов модели / слоя;
  • set_weights() – установка коэффициентов модели / слоя;
  • save_weights() – запись коэффициентов модели / слоя на носитель;
  • set_weights() – загрузка коэффициентов модели / слоя с носителя.
model = NeuralNetwork([128, 10]) model2 = NeuralNetwork([128, 10])

Затем, пропустить через них входной сигнал (для формирования весовых коэффициентов в слоях):

y = model.predict(tf.expand_dims(x_test[0], axis=0)) print(y) y = model2.predict(tf.expand_dims(x_test[0], axis=0)) print(y)

А потом скопировать веса, допустим, из первой модели во вторую:

# считываем и записываем веса только после пропускания через модели входного сигнала # иначе возникнет ошибка из-за отсутствия начальной инициализации весов weights = model.get_weights() model2.set_weights(weights) y = model2.predict(tf.expand_dims(x_test[0], axis=0)) print(y)

Как видим, последний вывод для y совпадает по значениям с первой моделью. Это показывает корректность копирования данных. Похожие действия можно выполнять и на уровне отдельных слоев, так как они поддерживают те же самые методы get_weights() и set_weights(). Вторая пара методов save_weights() и load_weights() позволяет сохранять веса на диск, а затем, считывать их обратно в модель. Делается это очень простопутем вызова этих методов для модели или слоя:

model.save_weights('model_weights') model2.load_weights('model_weights')
  • model_weights.data-00000-of-00001 – значения весовых коэффициентов;
  • model_weights.index – индексный вспомогательный файл.
model.save_weights('model_weights.h5') model2.load_weights('model_weights.h5')

TensorFlowJS: использование обученных моделей без их модификаций в браузере

При работе с TensorFlowJS можно выделить три направления его использования (рисунок 1):

  1. Использование обученных моделей без модификаций топологий и без их переобучений
  2. Использование предварительно обученную модель с возможной модификацией ее топологии или переобучении на базе новой тренировочной выборки данных, которая полностью соответствует решаемой вашей задачи
  3. Создание и обучение моделей с нуля

В данной статье, мы подробно рассмотрим как вы можете использовать уже обученные модели без модификации топологии и из переобучении, т.е. первое направление использование библиотеки.

1. Использование моделей через абстрактный АПИ

Этот тот случай, когда вам не потребуются какие-то глубокие знания по машинному обучению в принципе. Вам даже не придется производить никаких манипуляций с входными данными для модели. Например, если искомая модель принимает на вход изображение размерностью 240×240 пикселей, а вы хотели бы использовать изображение 20×30, то вам бы пришлось делать манипуляции над изображением, чтобы она была совместима с моделью. Также достаточно часто, модели требуют нормализацию входных данных (значения в одном цветом канале для пикселей изменяются от 0 до 256, однако для лучшей сходимости модели могут иногда требовать, чтобы величина каждого пиксела была в интервале [0, 1] или [-1, 1]).

Однако этот тип моделей абстрагирован таким образом, что единственным следом того, что внутри модели используется TensorFlowJS – это будет только импорт этой библиотеки вместе с моделью.

Рисунок 2 – Классификация моделей по типу решаемых задач

На момент написания статьи (октябрь 2020), Google представил 13 официальных моделей для использования в открытом доступе. Весь список моделей может быть найден тут. В списке вы можете найти модели, решающие следующие типы задач (рисунок 2):

  • классификация изображений: MobileNet — классификация изображений между 1000 категорий, при этом на изображении должен находится объект одного класса с нейтральным фоном (ссылка)
  • обнаружение объектов на изображении с указанием пространственных координат: Coco-SSD – определение объектов на изображении с указанием окна, в котором находится объект; модель может распознавать 80 разных категорий объектов (ссылка)
  • определение положения человеческого тела:BodyPix – пространственное определение частей тела (руки, ноги, плечи, глаза, уши), а также с помощью модели можно построить маску положения тела. На изображении одновременно может находиться несколько человек (ссылка)
  • распознавание голосовых команд: SpeechCommands – распознавание звуковых команд; в исходнос состоянии модель может распознавать команды из словаря из 20 слов на английском языке, например: ‘go’, ‘stop’, ‘yes’, ‘no’ (ссылка)
  • текстовая классификация: Toxicity – определяет содержит ли сообщения не приемлемый контент, содержащий оскорбления, не уважение, непристойные выражения с сексуальным содержанием (ссылка)
  • текстовая классификация: Toxicity – определяет содержит ли сообщения не приемлемый контент, содержащий оскорбления, не уважение, непристойные выражения с сексуальным содержанием (ссылка)
    — .

Давайте рассмотрим АПИ конкретной модели Coco-SSD и каким образом оно может быть использовано:

import * as tf from "@tensorflow/tfjs"; import * as cocoSsd from "@tensorflow-models/coco-ssd"; // other imports export default () => < const = useVideoStream(); const canvasRef = useRef(null); const modelRef = useRef(); function detectFrame() < if (modelRef.current && canvasRef.current && videoRef.current) < modelRef.current.detect(videoRef.current) .then(objects =>< buildObjectReactangle(canvasRef.current, objects); window.requestAnimationFrame(detectFrame); >); > > useEffect(() => < cocoSsd.load().then(model =>< modelRef.current = model; detectFrame(); >); >, []); return ( 
>>
); >

В первую очередь, необходимо сделать импорт модели и библиотеки @tensorflow/tfjs, этот тот единственный след, говорящий, что под капотом модель использует TensorFlowJS. При первом рендеринге React компонента необходимо загрузить модель: cocoSsd.load (строки 22-27). Как только модель будет загружена (это может занять некоторое время), можно запускать процесс обработки кадров, получаемые с видео потока вызовом detectFrame функции (строка 25). Для получения метаинформации о положении объектов на изображении – достаточно вызвать метод model.detect, первым аргументом которого является ссылка на DOM элемент video (строка 14). Этот метод возвращает Promise, результатом которого является массив с метаинформацией о каждом объекте, который был определен моделью в следующем формате:

Функция buildObjectReactngle – отрисовывает области на canvas вокруг объектов, распознанных моделью. Canvas наложен на видео поток сверху.

Здесь ссылка на git-repository с полным кодом.

2. Использование сериализированных обученных моделей TensorFlow

В связи с тем, что некоторые модели могут обучаться днями, неделями или месяцами, то очевидным становится факт, что необходим механизм сохранения моделей на промежуточных шагах обучения.

В TensorFlow.js в АПИ есть специальный метод tf.GraphModel.save. Модель сохраняется в TensorFlowJS JSON формате. Это набор файлов model.json и один или более бинарных файлов (рисунок 3). Файл model.json содержит информацию о топологии сети и имеет исчерпывающую информации о классах, из которых состоит модель, а также конфигурации слоев модели. Бинарные файлы содержат значения весов всех слоев модели и если модель имеет большое число параметров, то они могут разбиваться на шарды, по умолчания каждый бинарный файл не более 4МБ.

Рисунок 3 – Структура сохраненной модели в формате TensorFlow.js JSON.

На самом деле TensorFlowJS может работать не только с моделями, которые были сохранены им же, но так же есть возможность работать с моделями, которые были обучены с помощью фреймворка Keras на языке Python, но сохраненных с помощью TensorFlow в формате SavedModel. Всего есть 3 типа формата сериализации моделей, которые вы сможете использовать с TensorFlowJS (рисунок 4):

  • TensorFlow SavedModel – формат модели по умолчанию, с которыми модели сохраняются с помощь TensorFlow;
  • Keras Model – модели, сохраняемые фреймворком Keras в формате HDF5;

TensorFlow Hub Model – модели, которые распространяются через специальную платформу TensorFlow Hub.

Однако перед использование SavedModel, Keras Model, Tensorflow Hub model в TensorFlowJS необходимо конвертировать эти модели с помощью tfjs_converter.

Тут следует обратить внимание, что модели в форматах SavedModel и TensorFlow Hub могут быть конвертированы только в формат tfjs_graph_model. Модели же, сохраненные в формате Keras, могут конвертированы как в формат tfjs_graph_model, так и в формат tfjs_layers_model.

Чем же отличаются tfjs_layers_model от tfjs_graph_model?

Модели в формате tf_js_graph_model преобразуются в экземпляр класса tf.FrozenModel, что означает что все параметры модели зафиксированы и не подлежат изменению. Таким образом, если вы хотели бы переобучить модель с новой выборкой входных данных, которая более релевантна решаемой вами задачи, или же изменить топологию модели на базе существующей – то вам такой формат модели не подойдет. Однако есть преимущество для этой модели — это что вычисление (inference time) будет значительно меньше, по сравнению с той же моделью, но преобразованной в формат tfjs_layers_model.

Модель в этом формате загружается с помощью следующего АПИ:

const model = tf.loadGraphModel('/path/to/model.json')

Если есть нужда в переобучении модели или изменении ее топологии на стороне браузера, то модель должна быть загружена в формате tfjs_layers_model. Модель в этом формате загружается с помощью следующего АПИ:

const model = tf.loadLayersModel('/path/to/model.json')

На рисунке 5 представлена сводная схема по вышесказанному.

Рисунок 5 – Сводная таблица по конвертации сериализованных моделей

Конвертор можно использовать прямо из командной строки или же его можно вызывать непосредственно в Python-скрипте.

Использование конвертора из командной строки

Для этого вам необходимо установить tensorflowjs:

$ pip install tensorflowjs

Предположим, мы имеем Keras модель, сохраненная в HDF5 формате в tfjs_layers_model формат, для этого достаточно вызвать команду:

$ tensorflowjs_converter \ --input_format keras \ --output_format tfjs_layers_model \ path/to/my_model.h5 \ path/to/tfjs_target_dir 

После работы конвертора, в папке path/to/tfjs_target_dir вы увидите знакомые уже вам файлы model.json и и бинарные файлы содержащие значения весов модели.

Использование конвертора из Python-скрипта

Установите зависимости для скрипта:

$ pipenv keras tensorflowjs

Keras предоставляет некоторый список стандартных обученных моделей, которые могут быть найдены по ссылке. Теперь, предположим, что мы хотим конвертировать популярную модель для классификации изображений MobileNetV2, тогда скрипт будет выглядеть так:

import keras import tensorflowjs as tfjs mobileNet = keras.applications.mobilenet_v2.MobileNetV2() tfjs.converters.save_keras_model(mobileNet, './model/from_python_script')

Некоторые ошибки, с которыми вы можете столкнуться

После того, как вы конвертировали модель в tfjs_layers_model и вы пытаетесь загрузить модель на клиенте с помощью tf.loadLayersModel, то можете получить такого рода ошибку:

Uncaught (in promise) Error: Unknown layer: Functional. This may be due to one of the following reasons: 1. The layer is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code. 2. The custom layer is defined in JavaScript, but is not registered properly with tf.serialization.registerClass(). at deserializeKerasObject (generic_utils.ts:242) at deserialize (serialization.ts:31) at loadLayersModelFromIOHandler (models.ts:294) at async loadModel (index.js:9)

Если снова взгляните на рисунок 3, то увидите, что файл содержит описание классов, на базе которых строится модель. При этом мы видим что модель создана с помощь класса Functional. Вам надо обратить внимание на версию TF.js, которую вы используете и его АПИ. В данном случае использовался TF.js версии 2.0, и если вы посмотрите на АПИ, то увидите, что в АПИ этой версии нет класса tf.Functional. Именно тут скрывается и проблема. Как его можно разрешить:
— обновить версию TF.js до версии, где в АПИ представлен класс tf.Functional
— в связи с тем, что tf.Functional extends tf.LayersModel, то в model.json файле вместо Functional в поле class_name нужно использовать Model

Также можете посмотреть об ошибке на stackoverflow тут.

Как использовать загруженную модель?

В отличии от упакованных моделей в абстрактный АПИ, тут нам не избежать знакомства с TensorFlow, так как помимо загрузки модели, нам также необходимо позаботится о передачи входных данных в модель.

Итак, давайте просто используем предварительно конвертированную модель MobileNetV2 из формата Keras в формат tfjs_graph_model для классификации изображений.

После загрузки изображения, для того чтобы понять в каком формате нам надо передавать данные в модель, посмотрите файл model.jsoninputs” поле:

 "inputs": < "input_1:0": < "name": "input_1:0", "dtype": "DT_FLOAT", "tensorShape": < "dim": [ < "size": "-1">, < "size": "224">, < "size": "224">, < "size": "3">] > > >,

Таким образом на вход модель необходимо передать 4D-tensor размерностью [null, 224, 224, 3], что соответствует [EXAMPLE_BATCH, WIDTH, HEIGHT, COLOR_CHANNELS]. Вдоль первой оси может располагаться одновременно несколько изображений, но так как мы будем разрабатывать приложение, которое позволяет пользователю загрузить только одно изображение, то в нашем случае на вход модели всегда будем передавать тензор размерностью [1, 224, 224, 3].

Также взглянем, что модель нам выдаст в файле model.json в поле “outputs”:

"outputs": < "Identity:0": < "name": "Identity:0", "dtype": "DT_FLOAT", "tensorShape": < "dim": [ < "size": "-1" >, < "size": "1000" >] > > >

Это 2D-тензор размерностью [null, 1000], где 1000 – это количество классов, на которые наша сеть может классифицировать изображения. Это так называемый one-hot вектор, в котором все значения равны нулю, за исключением одного, например [0, 0, 1, 0, 0] – это значит что нейронная сеть считает с вероятностью 1, что на изображении класс с индексом 2 (индексация как обычно начинается с нуля). Когда мы будет использовать модель, то этот вектор будет представлять собой распределение вероятности для каждого из классов, например, можно получить такие значения: [0.07, 0.1, 0.03, 0.75, 0.05]. Обратите внимание, что сумма всех значений будет равна 1, а модель считает с максимальной вероятностью 0.75, что это объект класса c индексом 3.

Теперь все готово. Полный код представлен тут:

import * as tf from '@tensorflow/tfjs'; import from '@tensorflow/tfjs'; // other dependencies export default () => < const [model, setModel] = useState(); const [image, setImage] = useState(); const [results, setResults] = useState([]); useEffect(() => < (async () =>< setModel(await tf.loadGraphModel('/mobileNetV2/model.json')); >)(); >, []); useEffect(() => < tf.tidy(() => < if (image?.image && model) < (async () => < const offset = tf.scalar(127.5); const input = tf.browser.fromPixels(image.image) // make image compatable with model input .resizeNearestNeighbor([224, 224]) // feature scale tensor image to range [-1, 1] .sub(offset).div(offset) .toFloat() // adding batch axis and convert tensor with shape // [224, 224, 3] to [1, 224, 224, 3] .expandDims(); const output = model.predict(input) as Tensor2D; const results = Array.from(await output.data()) .map((item, i) =>()) .sort((a1, a2) => a2.probability - a1.probability) .slice(0, 5); setResults(results); >)(); > >); >, [image]); return ( 
/>> alt=/>> 0 && results.map((item, i) => (
> with probability ))>
); >

При рендеринге реакт-компонента, мы загружаем модель, которая была конвертирована с Keras (строки 10-14). Как только модель будет загружена – пользователю откроется возможность загружать изображение для классификации.

Как только пользователь выберет изображение – мы для начала должны преобразовать изображения в тензор размерностью [224, 224, 3], а так же необходимо нормализировать данные, чтобы значения пикселей было в промежутке [-1, 1]. Передадим этот тензор модели и получим выходной тензор (строка 30). Теперь нам надо всего лишь сопоставить текстовые метки с индексами, и вывести пять наиболее вероятных классов для загруженного изображения.

Обратите тут внимание, что функция обернута в tf.tidy – это важная деталь. Для увеличения производительности, TensorFlow.js в браузере обычно вычисления производит с помощью WebGL, и к сожалению тут нет механизма сборщика мусора, который автоматически как-то мог бы понять, что некоторые тензоры уже не нужны и можно высвободить память с WebGL. Чтобы этот процесс не был ручным (потому что каждый тензор в своем АПИ имеет метод dispose, который высвобождает память), мы оборачиваем операции над тензором в tf.tidy и после исполнения функции выживут только те тензоры, которые возвращаются этой функцией, а все оставшиеся тензоры будут уничтожены. Так как мы ничего не возвращаем из функции — то все тензоры будут уничтожены после ее исполнения.

Полный код вы можете найти в git-repository тут

  • tensorflow
  • tensorflow graph
  • tensorflow-js
  • ReactJS
  • Машинное обучение
  • TensorFlow

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *