Сохранение нейронной сети в JSON и другое: обучаем нейронную сеть на JavaScript
Когда речь идет о задачах, отличных от обработки больших массивов информации, человеческий мозг обладает большим преимуществом по сравнению с компьютером. Человек может распознавать лица, даже если в помещении будет много посторонних объектов и плохое освещение. Мы легко понимаем незнакомцев, даже когда находимся в шумном помещении. Но, несмотря на годы исследований, компьютеры все еще далеки от выполнения подобных задач на высоком уровне.
Искусственные нейронные сети применяются в различных областях науки, начиная с систем распознавания речи и заканчивая системами распознавания вторичной структуры белка, классификации различных видов рака и генной инженерии.
Сегодня нейронные сети популярны как никогда. Свои решения в этой области представляют такие компании, как Google, Microsoft и многие другие. Но существуют и библиотеки с открытым кодом, написанные энтузиастами на самых разных языках. Сегодня tproger расскажет вам об одной из них — это библиотека brain, написанная на JavaScript.
Использование
Самый простой пример применения — обучение на функции XOR:
var net = new brain.NeuralNetwork(); net.train([, , , ]); var output = net.run([1, 0]); // [0.987] А еще есть очень классная визуализация того, как нейронная сеть обучается XOR, OR и другим логическим функциям.
Чтобы установить библиотеку, можно использовать, например, npm:
npm install brain
Можно также скачать последнюю версию brain.js. Тренировать сеть можно даже оффлайн, а затем уже натренированную загрузить на сайт.
Чтобы начать обучать сеть, нужно использовать функцию train() , в которую передаются данные для обучения в виде массива. Сеть будет обучаться всеми данными сразу в одном вызове train() . Чем больше моделей обучения — тем дольше сеть будет обучаться, но и справляться со своей задачей она после этого будет лучше.
Каждая модель для обучения должна иметь параметры input и output , каждый из которых составляет массив или хэш чисел от 0 до 1. Например, для демо с распознаванием контрастности цветов это выглядело так:
var net = new brain.NeuralNetwork(); net.train([, output: < black: 1 >>, , output: < white: 1 >>, , output: < white: 1 >>]); var output = net.run(< r: 1, g: 0.4, b: 0 >); //
Функция train() умеет принимать в качестве второго аргумента массив нескольких параметров:
net.train(data, < errorThresh: 0.005, // порог ошибок, которого нужно достичь iterations: 20000, // максимальное число итераций обучения log: true, // нужен ли периодический console.log() logPeriod: 10, // число итераций между логированиями learningRate: 0.3 // степень обучения >) Обучаться сеть будет до тех пор, пока не будет достигнут заданный порог ошибок (по умолчанию задается 0.005) или не будет совершено заданное число итераций (20000).
По умолчанию вы никак не можете определить, как много времени осталось до конца обучения, но зато можно поставить на true параметр log, чтобы отслеживать ход обучения. Если передать в качестве этого параметра функцию, то она будет вызываться каждый раз через каждое заданное число итераций.
learningRate — параметр, определяющий, как быстро натренируется нейронная сеть. Задается он числом от 0 до 1. Чем меньше параметр, тем дольше сеть будет обучаться. С увеличением числа скорость будет расти, но вместе с этим растет вероятность более плохого качества обучения. По умолчанию это число составляет 0.3.
Результатом обучения будет массив output с информацией о том, как прошло обучение.
Если обучение закончилось ошибкой, то параметр error будет близок к порогу ошибки. Причиной этому может стать излишняя «зашумленность» данных, недостаток нейронов или недостаточное число итераций. Если даже после 20000 итераций ошибка составила около 0.4, это может означать, что сеть плохо воспринимает предоставляемые вами данные.
Обученную сеть можно хранить в формате JSON:
var json = net.toJSON(); net.fromJSON(json); Также можно данных сохранить в функцию:
var run = net.toFunction(); var output = run(< r: 1, g: 0.4, b: 0 >); console.log(run.toString()); // это нужно скопировать и вставить в нужное место. Подключать brain.js не требуется NeuralNetwork() принимает ассоциативный массив параметров:
var net = new brain.NeuralNetwork(< hiddenLayers: [4], learningRate: 0.6 // общая степень обученности, полезна при обучении в несколько потоков >); Первый параметр — общее количество скрытых слоев и размер каждого слоя. Например, если нужно два скрытых слоя — один с 3 нодами и второй с 4, то параметр будет таким:
hiddenLayers: [3, 4]
По умолчанию brain использует один слой, пропорциональный размеру входного массива.
Кстати, сеть может использовать WriteStream. Ее можно тренировать, используя pipe() , чтобы отправлять данные в сеть.
Чтобы тренировать сеть в потоке, сначала нужно поток создать вызовом метода net.createTrainStream() , принимающего следующие параметры:
- floodCallback() — функция, которая будет вызываться на каждой итерации обучения;
- doneTrainingCallback(info) — функция, которая выполнится после завершения обучения. Параметр info будет содержать ассоциативный массив информации о том, как прошло обучение:
Также можно использовать Transform, чтобы привести данные к корректному формату или чтобы на лету нормализовывать данные.
Памятка по TensorFlow: привет глубокому обучению!
Вы хотите освоить глубокое обучение с помощью TensorFlow? Независимо от того, являетесь ли вы новичком или опытным специалистом по данным, наша исчерпывающая шпаргалка по TensorFlow поможет вам. С помощью этой памятки вы сможете изучить основы TensorFlow, узнать о его возможностях и вывести свои навыки глубокого обучения на новый уровень.
Почему Tensorflow?
Исследования показали, что TensorFlow — эффективная и масштабируемая платформа для задач глубокого обучения. Исследование, проведённое сотрудниками Google, показало, что TensorFlow превзошёл другие популярные фреймворки глубокого обучения, достигнув более высокой производительности и более быстрого обучения в крупномасштабных нейронных сетях.
Другой эксперимент, проведённый исследователями из Массачусетского технологического института и Калифорнийского университета в Беркли, показал, что TensorFlow — это универсальный инструмент для разработки и развёртывания моделей глубокого обучения в самых разных приложениях.
Шпаргалка по Tensorflow
Эта шпаргалка специально разработана для тех, кто работает с Python и Data Science, что делает её ценным инструментом для всех, кто хочет погрузиться в мир глубокого обучения.
Итак, если вы готовы упростить своё путешествие по глубокому обучению, давайте подробнее рассмотрим, что может предложить эта шпаргалка.
Приготовьтесь сказать привет глубокому обучению с TensorFlow!
Импорт TensorFlow и проверка версии
Прежде чем приступить к работе с TensorFlow, вам необходимо импортировать библиотеку и убедиться, что у вас установлена правильная версия. Этот процесс включает в себя использование оператора import и атрибута __version__.
# Importing TensorFlow and checking the version import tensorflow as tf print(‘TensorFlow version:’, tf.__version__)
В этом коде мы импортируем TensorFlow с помощью оператора import и проверяем версию, благодаря атрибуту __version__.
Построение последовательной модели в TensorFlow
В TensorFlow вы можете построить последовательную модель, создав экземпляр объекта Sequential и добавив к нему слои с помощью метода add(). Этот процесс включает в себя определение архитектуры модели, в том числе входные и выходные формы, функции активации и количество единиц в каждом слое.
# Building a sequential model model = tf.keras.Sequential([ tf.keras.layers.Dense(64, activation=’relu’, input_shape=(784,)), tf.keras.layers.Dense(10, activation=’softmax’) ])
В этом коде мы создаём последовательную модель с двумя плотными слоями, используя объект Sequential и класс слоя Dense. Мы определяем входную форму первого слоя как кортеж (784,), который соответствует плоской форме набора данных MNIST. Также мы указываем функцию активации для каждого слоя ( relu для первого слоя и softmax для выходного слоя), а также количество единиц в каждом слое ( 64 для первого слоя и 10 для выходного слоя).
Компиляция модели в TensorFlow
После построения модели в TensorFlow перед обучением её необходимо скомпилировать. Этот процесс включает в себя указание функции потерь, оптимизатора и метрики оценки для модели с использованием метода compile().
# Compiling the model model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
В этом коде мы компилируем последовательную модель с помощью метода compile() и указываем функцию потерь categorical_crossentropy, оптимизатор adam и метрику accuracy для оценки во время обучения.
Обучение модели в TensorFlow
Чтобы обучить модель в TensorFlow, вам нужно вызвать метод fit() на скомпилированной модели и передать данные обучения и проверки, а также размер пакета и количество эпох.
# Training the model model.fit(X_train, y_train, batch_size=32, epochs=10, validation_data=(X_val, y_val))
В этом коде мы обучаем скомпилированную модель с помощью метода fit() и передаём обучающие данные ( X_train и y_train), размер партии ( 32), количество эпох ( 10) и данные проверки ( X_val и y_val). Модель будет обучаться в течение 10 эпох с размером пакета 32 и проверять данные проверки после каждой эпохи.
Оценка модели в TensorFlow
После того, как вы обучили модель в TensorFlow, вы можете оценить её производительность на тестовом наборе с помощью метода evaluate(). Этот процесс включает в себя передачу тестовых данных в качестве аргументов и вычисление метрики потерь и оценки в тестовом наборе.
# Evaluating the model loss, accuracy = model.evaluate(X_test, y_test) print(‘Test Loss:’, loss) print(‘Test Accuracy:’, accuracy)
В этом коде мы оцениваем обученную модель с помощью метода evaluate() и передаём тестовые данные ( X_test и y_test). Затем мы вычисляем метрики потерь и точности в тестовом наборе и выводим их.
Сохранение и загрузка модели в TensorFlow
В TensorFlow вы можете сохранить обученную модель на диск с помощью метода save()и загрузить её обратно в память с помощью функции load_model(). Это позволяет повторно использовать обученную модель в будущих сеансах без необходимости переобучения её с нуля.
# Saving the model to disk model.save(‘my_model.h5’) # Loading the model from disk new_model = tf.keras.models.load_model(‘my_model.h5’)
В этом коде мы сохраняем обученную модель на диск с помощью метода save()и загружаем её обратно в память с помощью функции load_model(). Мы сохраняем модель как файл HDF5 с именем my_model.h5 и загружаем её обратно в новую переменную с именем new_model.
Использование обратных вызовов в TensorFlow
В TensorFlow вы можете использовать обратные вызовы для настройки поведения процесса обучения. Обратные вызовы — это функции, которые выполняются во время обучения в определённых точках, таких как начало или конец эпохи. Их можно использовать для таких задач, как сохранение модели, ранняя остановка или снижение скорости обучения.
# Defining a callback function callback = tf.keras.callbacks.EarlyStopping(monitor=’val_loss’, patience=3) # Training the model with the callback function model.fit(X_train, y_train, batch_size=32, epochs=10, validation_data=(X_val, y_val), callbacks=[callback])
Объяснение: В этом коде мы определяем функцию обратного вызова, которая выполняет досрочную остановку, если потеря проверки не улучшится после трёх эпох. Мы создаём экземпляр обратного вызова EarlyStopping и передаём его методу fit() в виде списка обратных вызовов. Модель будет обучаться в течение 10 эпох и остановится раньше, если потеря проверки не улучшится после трёх эпох.
Использование регуляризации в TensorFlow
В TensorFlow вы можете использовать методы регуляризации, такие как L1, L2 и отсев, чтобы предотвратить переобучение в ваших моделях. Регуляризация включает в себя добавление штрафов к функции потерь, которые препятствуют использованию больших весов или активаций в модели.
# Adding L2 regularization to a dense layer model.add(tf.keras.layers.Dense(64, activation=’relu’, kernel_regularizer=tf.keras.regularizers.l2(0.01)))
В этом коде мы добавляем регуляризацию L2 к плотному слою модели, передавая аргумент kernel_regularizer конструктору слоя Dense. Указываем силу регуляризации использования 0.01 функции l2() из модуля tf.keras.regularizers.
Использование свёрточных слоев в TensorFlow
В TensorFlow вы можете использовать свёрточные слои для извлечения признаков из изображений и других многомерных данных. Свёрточные слои состоят из фильтров, которые скользят по входным данным и создают карту объектов.
# Adding a 2D convolutional layer model.add(tf.keras.layers.Conv2D(32, (3, 3), activation=’relu’, input_shape=(28, 28, 1))) # Adding a 2D max pooling layer model.add(tf.keras.layers.MaxPooling2D((2, 2)))
В этом коде мы добавляем к модели двухмерный свёрточный слой, используя класс Conv2D слоя. Мы указываем фильтры размера (3, 3), активации relu и входной формы (28, 28, 1)(соответствующей набору данных MNIST). Затем мы добавляем слой пула 2D max, используя класс слоя MaxPooling2D с размером пула (2, 2).
Использование повторяющихся слоёв в TensorFlow
В TensorFlow вы можете использовать повторяющиеся слои для моделирования последовательных данных, таких как временные ряды или естественный язык. Рекуррентные слои состоят из рекуррентных блоков, которые обрабатывают каждый элемент в последовательности и создают выходное и скрытое состояние, которые передаются следующему блоку.
# Adding a simple RNN layer model.add(tf.keras.layers.SimpleRNN(64, activation=’relu’, input_shape=(None, 1))) # Adding a LSTM layer model.add(tf.keras.layers.LSTM(64, activation=’relu’))
В этом коде мы добавляем в модель слой простой рекуррентной нейронной сети (RNN), используя класс слоя SimpleRNN . Мы указываем 64 повторяющиеся единицы, активацию relu и входную форму (None, 1)(где None представляет любую длину последовательности). Затем мы добавляем слой долговременной кратковременной памяти (LSTM), используя класс словя LSTM с теми же параметрами.
Использование трансферного обучения в TensorFlow
Трансферное обучение — это метод, в котором предварительно обученная модель используется в качестве отправной точки для новой задачи. В TensorFlow вы можете использовать предварительно обученные модели из таких источников, как TensorFlow Hub или модуль приложений Keras, для выполнения трансферного обучения.
# Loading a pre-trained model base_model = tf.keras.applications.MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights=’imagenet’) # Freezing the pre-trained layers for layer in base_model.layers: layer.trainable = False # Adding new output layers for a new task x = tf.keras.layers.GlobalAveragePooling2D()(base_model.output) x = tf.keras.layers.Dense(128, activation=’relu’)(x) predictions = tf.keras.layers.Dense(10, activation=’softmax’)(x) # Creating a new model model = tf.keras.models.Model(inputs=base_model.input, outputs=predictions)
В этом коде мы загружаем предварительно обученную модель MobileNetV2 из модуля Keras Applications с входной формой (224, 224, 3)верхнего уровня классификации и без него.
Затем мы заморозим предварительно обученные слои, установив для их атрибута trainable значение False.
Мы добавляем новые выходные слои для новой задачи, применяя глобальное усреднение к выходным данным базовой модели, добавляя плотный слой с 128 единицами и активацией relu и добавляя плотный слой с 10 единицами и активацией softmax. Наконец, мы создаём новую модель, которая принимает входные данные базовой модели и выводит новые прогнозы.
Использование пользовательских функций потерь в TensorFlow
В TensorFlow вы можете определить собственные функции потерь для своих моделей с помощью модуля tf.keras.losses. Это позволяет вам создавать функции потерь, адаптированные к вашей конкретной проблеме, которые могут включать дополнительные условия или штрафы.
# Defining a custom loss function def custom_loss(y_true, y_pred): squared_difference = tf.square(y_true — y_pred) return tf.reduce_mean(squared_difference, axis=-1) # Compiling the model with the custom loss function model.compile(optimizer=’adam’, loss=custom_loss)
В этом коде мы определяем пользовательскую функцию потерь custom_loss, которая вычисляет среднеквадратичную ошибку между истинным и прогнозируемым значениями. Мы используем операции TensorFlow для вычисления квадрата разницы и уменьшения среднего по последней оси. Затем мы компилируем модель с оптимизатором adam и пользовательской функцией потерь.
Использование пользовательских метрик в TensorFlow
В TensorFlow вы можете определить пользовательские метрики для оценки производительности ваших моделей во время обучения и тестирования. Пользовательские показатели могут быть определены с помощью модуля tf.keras.metrics и могут включать дополнительные условия или штрафы.
# Defining a custom metric function def custom_metric(y_true, y_pred): absolute_difference = tf.abs(y_true — y_pred) return tf.reduce_mean(absolute_difference, axis=-1) # Compiling the model with the custom metric model.compile(optimizer=’adam’, loss=’sparse_categorical_crossentropy’, metrics=[custom_metric])
В этом коде мы определяем пользовательскую метрику custom_metric, которая вычисляет среднюю абсолютную ошибку между истинным и прогнозируемым значениями. Мы используем операции TensorFlow для вычисления абсолютной разницы и уменьшения среднего по последней оси. Затем мы компилируем модель с оптимизатором adam, разреженной категориальной функцией кросс-энтропийных потерь и пользовательской метрикой.
Использование функционального API в TensorFlow
Функциональный API Keras позволяет создавать сложные модели с несколькими входами и выходами, общими слоями и нелинейными связями между слоями.
# Defining the inputs input_1 = tf.keras.layers.Input(shape=(28, 28, 1)) input_2 = tf.keras.layers.Input(shape=(10,)) # Adding some layers to the first input x = tf.keras.layers.Conv2D(32, (3, 3), activation=’relu’)(input_1) x = tf.keras.layers.MaxPooling2D((2, 2))(x) x = tf.keras.layers.Flatten()(x) # Merging the inputs with a shared layer merged = tf.keras.layers.concatenate([x, input_2]) # Adding some more layers y = tf.keras.layers.Dense(64, activation=’relu’)(merged) output = tf.keras.layers.Dense(10, activation=’softmax’)(y) # Creating the model model = tf.keras.models.Model(inputs=[input_1, input_2], outputs=output)
В этом коде мы определяем два входа для модели: input_1 для данных изображения и input_2 для дополнительных функций.
Мы добавляем несколько слоёв к первому входу для обработки данных изображения, включая слой свёртки 2D, слой максимального объединения и слой сглаживания.
Затем мы объединяем выходные данные этих слоёв со вторым входом, используя конкатенированный слой.
Мы добавляем ещё несколько слоёв к объединённому выводу, в том числе плотный слой с 64 единицами и активацией relu и плотный выходной слой с 10 единицами и активацией softmax. Наконец, мы создаём модель с классом Model, используя входные и выходные данные.
Использование обратных вызовов в TensorFlow
В TensorFlow вы можете использовать обратные вызовы для настройки поведения ваших моделей во время обучения. Обратные вызовы — это функции, которые вызываются в определённые моменты во время обучения, например, в конце каждой эпохи, и могут выполнять такие задачи, как сохранение модели, ранняя остановка или изменение скорости обучения.
# Defining a callback for early stopping early_stopping_callback = tf.keras.callbacks.EarlyStopping(monitor=’val_loss’, patience=3) # Fitting the model with callbacks history = model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val), callbacks=[early_stopping_callback])
В этом коде мы определяем обратный вызов, вызываемый early_stopping_callback с использованием класса EarlyStopping из модуля tf.keras.callbacks. Этот обратный вызов будет отслеживать потерю проверки и останавливать обучение, если оно не улучшается в течение 3 последовательных эпох. Затем мы подгоняем модель к обучающим данным для 10 эпох с включёнными проверочными данными и обратным вызовом. Переменная history будет содержать информацию о производительности обучения и проверки с течением времени.
Заключение
В этой статье мы рассмотрели возможности и универсальность TensorFlow, популярной платформы с открытым исходным кодом для глубокого обучения.
Мы рассмотрели ряд тем, включая основы TensorFlow, создание и обучение глубоких нейронных сетей и применение этих методов в реальных приложениях.
С TensorFlow вы можете упростить процесс глубокого обучения и вывести свои навыки на новый уровень.
Используя TensorFlow, вы можете исследовать возможности глубокого обучения и получать новые знания из ваших данных.
Так зачем ждать? Начните изучать мощь TensorFlow сегодня и раскройте потенциал своих данных!
Использование обученной модели нейронной сети
Вопросы такие:
Как использовать обученную Tensorflow RNN в GoogleCoLab на локальной машине?
Нужно скачать с CoLab файл с весами или какой-то другой, или их все?
И потом как использовать?
Разместить в корне, и можно ли импортить необходимые методы?
Или нужно сохранить модель в формат .h5 и после использовать?
Например создать простой prosto.py в котором:
И как в таком случае подать t в обученную модель?
Нужен ли для этого исходник модели?
Знающие, помогите пожалуйста!
Отслеживать
Galo Gramma
задан 7 ноя 2019 в 17:23
Galo Gramma Galo Gramma
135 1 1 серебряный знак 10 10 бронзовых знаков
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
Существуют методы save() и load() для сохранения модели и последующей загрузки где хотите. Для использования существует метод predict()
Отслеживать
ответ дан 8 ноя 2019 в 18:03
376 2 2 серебряных знака 13 13 бронзовых знаков
При применении метода save() сохраняются чекпоинты в виде 4 файлов — модель, веса и указания что где. Вопрос в том.. Как использовать эти файлы на локальной машине?
9 ноя 2019 в 16:13
Архитектура модели — состоит из двух рекуррентных нейронных сетей: кодер RNN просто потребляет входные слова источника без каких-либо предсказаний; Декодер, с другой стороны, обрабатывает целевое предложение, предсказывая следующие слова.
9 ноя 2019 в 16:50
@GaloGramma метод load() запускаешь из того же репозитория, где сохранил. Тоесть он загружает сразу весь репозиторий с твоей моделью. Далее с помощью метода predict() используешь модель для предсказания/генерации. Я так полагаю, у вас что-то вроде GAN. Тогда после обучения стоит сохранять именно генератор, т.к. дискриминатор нужен лишь на период обучения)
11 ноя 2019 в 19:16
Большое спасибо за ответ, но пока что не до конца понятен принцип. Очень прошу Вас разъяснить более подробно! Я пока не сохранял модель в репозиторий. На данном этапе я лишь обучил модель на ноутбуке Google CoLab используя простой дата сет и получил сохраненные файлы чекпоинтов. Скачал их с CoLab на лок маш и не понимаю, что с ними дальше делать. Нужно ли восстанавливать исходную модель на лок маш? Нужен ли .HDF5 для использования модели на лок маш? Модель состоит из двух рекурентных сеток — (1)Encoder, (2)Decoder.
Как сохранить модель keras?
Вылетает ошибка:
Traceback (most recent call last):
File «main.py», line 677, in
run.main()
File «main.py», line 673, in main
model = load_model(«model.h5»)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\engine\saving.py», line 229, in load_model
model_config = json.loads(model_config.decode(‘utf-8’))
AttributeError: ‘str’ object has no attribute ‘decode’
Что я не так делаю?
Лучшие ответы ( 1 )
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:
Keras — классификация текста — оверфиттинг, и как улучшить модель
Я делаю нейронную сеть для классификации текста на русском языке по этим примерам — .
Как уменьшить размер тензора keras?
Доброго времени суток, есть тензор из 1628670 элементов, задача через reshape сделать его размеров.
Как сохранить модель Компас из V16 в V12?
Нужно сдать проект в лицее, но не знаю как сохранить так, чтобы загружалось в 13 компасе. Поэтому.
Как сохранить координаты маркера из ГуглМап в модель ГеоДжанго?
models.py: class Location(models.Model): name = models.CharField(max_length=100.
Flask-WTF: как сохранить модель со связью One-to-Many в базу данных?
Есть две модели Datacener и Server с общей связью ForeigKey, при попытке создать новую модель.
2684 / 1590 / 512
Регистрация: 21.02.2017
Сообщений: 4,207
Записей в блоге: 1
Не благодари:
Сообщение от Andrei_ 
AttributeError: ‘str’ object has no attribute ‘decode’
533 / 438 / 47
Регистрация: 17.07.2013
Сообщений: 2,236
Сообщение от Andrei_
model = load_model(«model.h5»)
Это не сохранение, а загрузка модели:
https://www.tensorflow.org/tut. e_and_load
Регистрация: 04.08.2020
Сообщений: 231
Да, читал документацию
Дело в том, что при использовании версии h5py==3.0.0 и выше вылетает ошибка:
AttributeError: ‘str’ object has no attribute ‘decode’
А при использовании версий ниже летит:
AttributeError: ‘NoneType’ object has no attribute ‘get’
533 / 438 / 47
Регистрация: 17.07.2013
Сообщений: 2,236
Сообщение от Andrei_
У меня работает, только сегодня сохранил и загрузил полсотни моделей
Регистрация: 04.08.2020
Сообщений: 231
У меня Python 3.7.0, tensorflow 1.12.0, h5py 2.9.0
Но все равно при попытке загрузки модели получаю:
Traceback (most recent call last):
File «main.py», line 679, in
run.main()
File «main.py», line 674, in recognition
model = load_model(«main.h5»)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\engine\saving.py», line 230, in load_model
model = model_from_config(model_config, custom_objects=custom_objects)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\engine\saving.py», line 310, in model_from_config
return deserialize(config, custom_objects=custom_objects)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\layers\serialization.py», line 64, in deserialize
printable_module_name=’layer’)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py», line 173, in deserialize_keras_object
list(custom_objects.items())))
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\engine\network.py», line 1292, in from_config
process_layer(layer_data)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\engine\network.py», line 1278, in process_layer
layer = deserialize_layer(layer_data, custom_objects=custom_objects)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\layers\serialization.py», line 64, in deserialize
printable_module_name=’layer’)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py», line 173, in deserialize_keras_object
list(custom_objects.items())))
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\layers\core.py», line 800, in from_config
printable_module_name=’function in Lambda layer’)
File «C:\Users\user\AppData\Local\Programs\Python\Python37\lib\site-packages\tensorflow\python\keras\utils\generic_utils.py», line 190, in deserialize_keras_object
fn = module_objects.get(function_name)
AttributeError: ‘NoneType’ object has no attribute ‘get’
533 / 438 / 47
Регистрация: 17.07.2013
Сообщений: 2,236
Сообщение от Andrei_
У меня Python 3.7.0, tensorflow 1.12.0
У меня tensorflow 2.3
Сделайте отладочный кусок программы — из десятка строк создайте, сохраните и загрузите модель.
Разбираться в сотнях строках Вашей программы времени и желания нет
Регистрация: 04.08.2020
Сообщений: 231
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
class KKK(): def model(self, input_shape): seq = Sequential() seq.add(Conv2D(6, 3, 3, activation="relu", input_shape=input_shape, padding='valid', data_format="channels_last")) seq.add(MaxPooling2D(pool_size=(2, 2))) seq.add(Dropout(0.25)) seq.add(Conv2D(12, 3, 3, activation="relu", padding='valid', data_format="channels_last")) seq.add(MaxPooling2D(pool_size=(2, 2), data_format='channels_last')) seq.add(Dropout(0.25)) seq.add(Flatten()) seq.add(Dense(128, activation='relu')) seq.add(Dropout(0.1)) seq.add(Dense(50, activation='relu')) return seq def euclidean_distance(self, vects): x, y = vects return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True)) def eucl_dist_output_shape(self, shapes): shape1, shape2 = shapes return (shape1[0], 1) def contrastive_loss(self, y_true, y_pred): margin = 1 return K.mean(y_true * K.square(y_pred) + (1 - y_true) * K.square(K.maximum(margin - y_pred, 0))) def train(self): X, Y = self.get_data() X.shape = (20000, 2, 56, 46, 1) x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=.25) input_dim = x_train.shape[2:] img_a = Input(shape=input_dim) img_b = Input(shape=input_dim) base_network = self.model(input_dim) feat_vecs_a = base_network(img_a) feat_vecs_b = base_network(img_b) distance = Lambda(self.euclidean_distance, output_shape=self.eucl_dist_output_shape)([feat_vecs_a, feat_vecs_b]) rms = RMSprop() model = Model(inputs=[img_a, img_b], outputs=distance) model.compile(loss=self.contrastive_loss, optimizer=rms) model.save("model.h5") from tensorflow.keras.models import load_model model = load_model("model.h5")