Как установить keras python
Перейти к содержимому

Как установить keras python

  • автор:

Как установить Keras на Linux и Windows / keras 2

В этом материале вы узнаете, как установить Keras на ОС Linux и Windows, а также ознакомитесь с проблемами, которые могут возникнуть в процессе, и требованиями для установки.

Как установить Keras на Linux

Keras — это фреймворк Python для глубокого обучения, поэтому в первую очередь нужно, чтобы Python был установлен в системе.

В Ubuntu он есть по умолчанию. Рекомендуется использовать последнюю версию, то есть python3. Для проверки наличия его в системе выполните следующее:

  1. Откройте терминал (Ctrl+Alt+T)
  2. Введите python3 -V или python3 –version

Выводом будет версия Python 3.

Python 3.6.9 

Если Python 3 не установлен, воспользуйтесь следующими инструкциями:

    Добавьте PPA , запустив следующую команду

sudo add-apt-repository ppa:jonathonf/python-3.6 
sudo apt-get update sudo apt-get install python3.6 

Теперь пришло время устанавливать Keras.

Но сначала нужно установить один из бэкенд-движков: Tensorflow, Theano или Microsoft CNTK. Лучше всего использовать первый.

Установите Tensorflow из PyPl:

pip3 install tensorflow 

Теперь установка Keras:

  • Установите Keras из PyPl:
pip3 install Keras 
  • Или установите его из Github:
git clone https://github.com/keras-team/keras.git 
cd Keras 
sudo python3 setup.py install 

Как установить Keras на Windows?

Прежде чем переходить к установке Keras, нужно убедиться, что в системе есть Python. Нужна версия как минимум Python 3.5+.

Для проверки установленной версии:

  1. Откройте cmd
  2. Введите python -V или python –version

Отобразится текущая версия Python.

Python 3.7.3 

Если Python не установлен или загружена более старая версия:

  1. Зайдите на сайт python.org
  2. Выберите последнюю версию Python для Windows
  3. В нижней части страницы выберите установочный файл Windows x86- для 64-битной версии системы или Windows x86 — для 32-битной.
  4. После загрузки программы установки дважды кликните по файлу.
  5. Снова проверьте версию Python в cmd

Теперь нужно установить один из движков: Tensorflow, Theano или Microsoft CNTK. Рекомендуется использовать первый.

Установите Tensofrflow с помощью пакетного менеджера pip3:

pip3 install tensorflow 

Теперь установите Keras

    Установите Keras из PyPl:

pip3 install Keras 
git clone https://github.com/keras-team/keras.git 
cd keras 
python3 setup.py install 

Создайте первую программу в Keras

Создадим регрессионную предсказательную модель на основе данных о ценах Boston Housing с помощью Keras. Данные включают 13 признаков домов и включают 506 объектов. Задача — предсказать цены.

Это классическая регрессионная проблема машинного обучения, а набор данных доступен в модуле Keras.dataset .

Реализация:

import numpy as np import pandas as pd # загрузить набор данных, это может занять некоторое время from keras.datasets import boston_housing (train_x,train_y),(test_x,test_y)=boston_housing.load_data() 

Нормализация данных

mean=train_x.mean(axis=0) train_x-=mean std=train_x.std(axis=0) train_x/=std test_x-=mean test_x/=std 

Построение нейронной сети

from keras import models, layers def build_model(): model=models.Sequential() model.add(layers.Dense(64,activation='relu',input_shape=(train_x.shape[1],))) model.add(layers.Dense(64,activation='relu')) model.add(layers.Dense(1)) model.compile(optimizer='rmsprop',loss='mse',metrics=['mae']) return model 

Тренировка модели

model=build_model() model.fit(train_x,train_y,epochs=80,batch_size=16,verbose=0) 

Оценка модели с помощью среднеквадратической ошибки модели и средней абсолютной ошибки

test_mse, test_mae=model.evaluate(test_x, test_y) test_mae 
2.6441757678985596 

Модель получает довольно высокую среднюю ошибку с этими данными. Лучшие результаты можно получить за счет дальнейшей предварительной обработки данных.

Выводы

Статья посвящена пошаговой установке Keras в Linux (Ubuntu) и Windows. Она также включает базовую реализацию предсказательной модели ценообразования Boston Housing, которая является хорошо исследованной регрессионной проблемой моделирования в машинном обучении.

Getting started with Keras

Are you a machine learning engineer looking for a Keras introduction one-pager? Read our guide Introduction to Keras for engineers.

Want to learn more about Keras 3 and its capabilities? See the Keras 3 launch announcement.

Are you looking for detailed guides covering in-depth usage of different parts of the Keras API? Read our Keras developer guides.

Are you looking for tutorials showing Keras in action across a wide range of use cases? See the Keras code examples: over 150 well-explained notebooks demonstrating Keras best practices in computer vision, natural language processing, and generative AI.

Installing Keras 3

You can install Keras from PyPI via:

pip install --upgrade keras 

You can check your local Keras version number via:

import keras print(keras.__version__) 

To use Keras 3, you will also need to install a backend framework – either JAX, TensorFlow, or PyTorch:

  • Installing JAX
  • Installing TensorFlow
  • Installing PyTorch

If you install TensorFlow, critically, you should reinstall Keras 3 afterwards. This is a temporary step while TensorFlow is pinned to Keras 2, and will no longer be necessary after TensorFlow 2.16. The cause is that tensorflow==2.15 will overwrite your Keras installation with keras==2.15 .

Installing KerasCV and KerasNLP

KerasCV and KerasNLP can be installed via pip:

pip install --upgrade keras-cv pip install --upgrade keras-nlp pip install --upgrade keras 

Critically, you should reinstall Keras 3 after installing KerasNLP. This is a temporary step while TensorFlow is pinned to Keras 2, and will no longer be necessary after TensorFlow 2.16. The cause is that keras-nlp depends on tensorflow-text , which will install tensorflow==2.15 , which will overwrite your Keras installation with keras==2.15 .

Configuring your backend

You can export the environment variable KERAS_BACKEND or you can edit your local config file at ~/.keras/keras.json to configure your backend. Available backend options are: «jax» , «tensorflow» , «torch» . Example:

export KERAS_BACKEND="jax" 

In Colab, you can do:

import os os.environ["KERAS_BACKEND"] = "jax" import keras 

Note: The backend must be configured before importing Keras, and the backend cannot be changed after the package has been imported.

GPU dependencies

Colab or Kaggle

If you are running on Colab or Kaggle, the GPU should already be configured, with the correct CUDA version. Installing a newer version of CUDA on Colab or Kaggle is typically not possible. Even though pip installers exist, they rely on a pre-installed NVIDIA driver and there is no way to update the driver on Colab or Kaggle.

Universal GPU environment

If you want to attempt to create a «universal environment» where any backend can use the GPU, we recommend following the dependency versions used by Colab (which seeks to solve this exact problem). You can install the CUDA driver from here, then pip install backends by following their respective CUDA installation instructions: Installing JAX, Installing TensorFlow, Installing PyTorch

Most stable GPU environment

This setup is recommended if you are a Keras contributor and are running Keras tests. It installs all backends but only gives GPU access to one backend at a time, avoiding potentially conflicting dependency requirements between backends. You can use the following backend-specific requirements files:

  • requirements-jax-cuda.txt
  • requirements-tensorflow-cuda.txt
  • requirements-torch-cuda.txt

These install all CUDA-enabled dependencies via pip. They expect a NVIDIA driver to be preinstalled. We recommend a clean python environment for each backend to avoid CUDA version mismatches. As an example, here is how to create a JAX GPU environment with Conda:

conda create -y -n keras-jax python=3.10 conda activate keras-jax pip install -r requirements-jax-cuda.txt pip install --upgrade keras 

TensorFlow + Keras 2 backwards compatibility

From TensorFlow 2.0 to TensorFlow 2.15 (included), doing pip install tensorflow will also install the corresponding version of Keras 2 – for instance, pip install tensorflow==2.14.0 will install keras==2.14.0 . That version of Keras is then available via both import keras and from tensorflow import keras (the tf.keras namespace).

Starting with TensorFlow 2.16, doing pip install tensorflow will install Keras 3. When you have TensorFlow >= 2.16 and Keras 3, then by default from tensorflow import keras ( tf.keras ) will be Keras 3.

Meanwhile, the legacy Keras 2 package is still being released regularly and is available on PyPI as tf_keras (or equivalently tf-keras – note that — and _ are equivalent in PyPI package names). To use it, you can install it via pip install tf_keras then import it via import tf_keras as keras .

Should you want tf.keras to stay on Keras 2 after upgrading to TensorFlow 2.16+, you can configure your TensorFlow installation so that tf.keras points to tf_keras . To achieve this:

  1. Make sure to install tf_keras . Note that TensorFlow does not install by default.
  2. Export the environment variable TF_USE_LEGACY_KERAS=1 .

There are several ways to export the environment variable:

  1. You can simply run the shell command export TF_USE_LEGACY_KERAS=1 before launching the Python interpreter.
  2. You can add export TF_USE_LEGACY_KERAS=1 to your .bashrc file. That way the variable will still be exported when you restart your shell.
  3. You can start your Python script with:
import os os.environ["TF_USE_LEGACY_KERAS"] = "1" 

These lines would need to be before any import tensorflow statement.

Compatibility matrix

JAX compatibility

The following Keras + JAX versions are compatible with each other:

  • jax==0.4.20 & keras==3.0.0

TensorFlow compatibility

The following Keras + TensorFlow versions are compatible with each other:

  • tensorflow==2.13.0 & keras==2.13.0
  • tensorflow==2.14.0 & keras==2.14.0
  • tensorflow==2.15.0 & keras==2.15.0
  • tensorflow==2.15.0 & keras==3.0.0
  • tensorflow==2.16.0 & keras==3.0.0

PyTorch compatibility

The following Keras + PyTorch versions are compatible with each other:

  • torch==2.1.0 & keras==3.0.0

Keras 3: Deep Learning for Humans

Keras 3 is a multi-backend deep learning framework, with support for TensorFlow, JAX, and PyTorch.

Installation

Install with pip

Keras 3 is available on PyPI as keras . Note that Keras 2 remains available as the tf-keras package.

pip install keras --upgrade 
  1. Install backend package(s).

To use keras , you should also install the backend of choice: tensorflow , jax , or torch . Note that tensorflow is required for using certain Keras 3 features: certain preprocessing layers as well as tf.data pipelines.

Local installation

Minimal installation

Keras 3 is compatible with Linux and MacOS systems. For Windows users, we recommend using WSL2 to run Keras. To install a local development version:

  1. Install dependencies:
pip install -r requirements.txt 
  1. Run installation command from the root directory.
python pip_build.py --install 
Adding GPU support

The requirements.txt file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also provide a separate requirements—cuda.txt for TensorFlow, JAX, and PyTorch. These install all CUDA dependencies via pip and expect a NVIDIA driver to be pre-installed. We recommend a clean python environment for each backend to avoid CUDA version mismatches. As an example, here is how to create a Jax GPU environment with conda :

conda create -y -n keras-jax  activate keras-jax pip install -r requirements-jax-cuda.txt python pip_build.py --install

Configuring your backend

You can export the environment variable KERAS_BACKEND or you can edit your local config file at ~/.keras/keras.json to configure your backend. Available backend options are: «tensorflow» , «jax» , «torch» . Example:

export KERAS_BACKEND="jax" 

In Colab, you can do:

Note: The backend must be configured before importing keras , and the backend cannot be changed after the package has been imported.

Backwards compatibility

Keras 3 is intended to work as a drop-in replacement for tf.keras (when using the TensorFlow backend). Just take your existing tf.keras code, make sure that your calls to model.save() are using the up-to-date .keras format, and you’re done.

If your tf.keras model does not include custom components, you can start running it on top of JAX or PyTorch immediately.

If it does include custom components (e.g. custom layers or a custom train_step() ), it is usually possible to convert it to a backend-agnostic implementation in just a few minutes.

In addition, Keras models can consume datasets in any format, regardless of the backend you’re using: you can train your models with your existing tf.data.Dataset pipelines or PyTorch DataLoaders .

Why use Keras 3?

  • Run your high-level Keras workflows on top of any framework — benefiting at will from the advantages of each framework, e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow.
  • Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework.
    • You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch.
    • You can take a Keras model and use it as part of a PyTorch-native Module or as part of a JAX-native model function.

    В помощь дата-сайентисту: настройка нейронной сети с помощью Python-библиотеки Keras

    Салют, Хабр! Построение нейронной сети ― весьма актуальная задача для самых разных направлений: от классификации продуктов на категории до распознавания лиц на видео. Однако для получения качественного результата необходимо грамотно настроить её параметры. Как это сделать? В этом может помочь Keras ― открытая библиотека, написанная на языке Python и обеспечивающая взаимодействие с искусственными нейронными сетями. Просим под кат, где подробно рассказываем о нюансах работы с этой библиотекой.

    Зачем эта статья?

    Наша команда решила поделиться опытом построения нейронной сети и регулирования её гиперпараметров с помощью Keras. Рассказываем и показываем практически.

    Анализ, о котором говорится ниже, мы провели на примере открытого датасета из Kaggle Otto group product classification challenge. Количество строк в нём составляет примерно 62 тысячи. Каждая строка соответствует одному продукту. Необходимо классифицировать продукты компании по девяти категориям, основываясь на 93 характеристиках. Каждая категория ― это тип продукта, например мода, электроника и т. д. Классы не сбалансированы, что можно увидеть на графике.

    Описательные статистики для переменных:

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

    Как это сделано?

    Что же, приступим. Для начала импортируем необходимые библиотеки:

    from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten from tensorflow.keras.optimizers import Adam,SGD,Adagrad from tensorflow.keras.wrappers.scikit_learn import KerasClassifier from tensorflow.keras.initializers import glorot_uniform

    На вход нейронной сети подаются тензоры. Это общая форма векторов в виде n-мерной матрицы. Если данные табличные (как в данном случае), то тензор будет двумерный, где каждый столбец этой матрицы ― это одно наблюдение из таблицы (одна строка табличных данных).

    y = x.target.values x.drop('target', axis=1, inplace=True) x = np.log(1+x.values)

    Общая структура сети разрабатывается с помощью объекта модели keras Sequential(), который создаёт последовательную модель с пошаговым добавлением слоёв в неё. Dense-слой является самым необходимым и базовым. Он отвечает за соединение нейронов из предыдущего и следующего слоя. Например, если первый слой имеет 5 нейронов, а второй 3, то общее количество соединений между слоями будет равно 15. Dense-слой отвечает за эти соединения, и у него есть настраиваемые гиперпараметры: количество нейронов, тип активации, инициализация типа ядра. Dropout Layer помогает избавиться от переобучения модели. Таким образом, некоторые нейроны становятся равными 0, и это сокращает вычисления в процессе обучения. Базовая модель представлена ниже:

    def getModel(dropout=0.00, neurons_first=500, neurons_second=250, learningRate=0.1): model = Sequential() model.add(Dense(neurons_first, activation='relu', input_dim=num_features, kernel_initializer=glorot_uniform(), name='Dense_first')) model.add(Dropout(dropout, name='Dropout_first')) model.add(Dense(neurons_second, activation='relu', kernel_initializer=glorot_uniform(), name='Dense_second')) model.add(Dropout(dropout, name='Dropout_second')) model.add(Dense(num_classes, activation='softmax', kernel_initializer=glorot_uniform(), name='Result')) model.compile(loss='sparse_categorical_crossentropy', optimizer=Adagrad(lr=learningRate), metrics=['accuracy']) return model

    Теперь давайте разберёмся с тем, что собой представляет функция активации. Так вот, каждый нейрон сети получает один или несколько входных сигналов от нейронов предыдущего слоя. Если речь идёт про первый скрытый слой, то он получает данные из входного потока. Начиная со второго скрытого слоя, на вход каждому нейрону подаётся взвешенная сумма нейронов из предыдущего слоя. На втором скрытом слое происходит активация входных данных за счёт функции активации. С помощью функции активации становится доступной реализация обратного распространения ошибки, которая помогает скорректировать веса нейронов. Таким образом происходит обучение модели. Важный момент ― существует несколько вариантов функции активации.

    Для текущей задачи использовались функции активации ReLu и Softmax. Функция ReLu выглядит следующим образом:

    Функция Softmax выглядит следующим образом:

    Функция потерь ― показатель, который помогает понять, движется ли сеть в правильном направлении. Так как задача решается для многоклассовой классификации, то использовалась функция потерь sparse categorical crossentropy:

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

    Что ещё?

    Наиболее важной частью обучения модели является оптимизатор. Ранее был упомянут термин обратного распространения ошибки ― это как раз и есть процесс оптимизации. Структура, которая ранее была описана, инициализируется случайными весами между нейронами слоёв. Процесс обучения нужен для того, чтобы обновить эти случайные веса для получения высокой предсказательной способности.

    Сеть берёт одну обучающую выборку и использует её значения в качестве входных данных слоя, далее происходит активация этих данных, и на вход следующему слою подаются уже новые взвешенные данные после активации. Аналогичный процесс происходит и на последующих слоях. Результат последнего слоя будет прогнозом для обучающей выборки. Далее применяется функция потерь, которая показывает, насколько сильно ошибается модель. Чтобы эту ошибку уменьшить, применяется ещё одна функция ― оптимизатора. Она использует производные для ответа на вопрос ― насколько сильно изменится функция потерь при небольшом изменении весов между нейронами?

    Вычисление одной обучающей выборки из входного слоя называется проходом. Обычно обучение происходит батчами из-за ограничений системы. Батч ― набор обучающих выборок из входных данных. Сеть обновляет свои веса после обработки всех выборок из батча. Это называется итерацией (то есть успешная обработка всех обучающих выборок из батча с последующим обновлением весов в сети). А вычисление всех обучающих выборок, которые были во входных данных, с периодическими обновлениями весов называется эпохой. На каждой итерации сеть использует функцию оптимизации, чтобы внести изменения в веса между нейронами. Шаг за шагом, с помощью нескольких итераций, а затем нескольких эпох, сеть обновляет свои веса и учится делать корректный прогноз. Существует много разных функций оптимизации. В нашем случае была использована Adagrad.

    Оптимизируем всё!

    Ну а теперь давайте попробуем улучшить качество модели. Здесь пригодится увеличение dropout rate. То есть теперь больше нейронов будут выходить из процесса обучения.

    increasedDropout = 0.5 model = getModel(increasedDropout) net = model.fit(X, y, epochs=15, batch_size=515, verbose=1, validation_split=0.2)

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

    Увеличение количества эпох.

    model = getModel(increasedDropout) net = model.fit(X, y, epochs=25, batch_size=515, verbose=1, validation_split=0.2)

    Заметно, что качество улучшилось. Задача выполнена, и сделали мы это весьма неплохо, правда?

    Увеличение количества нейронов.

    increasedNeurons1 = 800 model = getModel(increasedDropout, neurons_first=increasedNeurons1) net = model.fit(X, y, epochs=25, batch_size=515, verbose=1, validation_split=0.2)

    Качество модели стало ещё лучше.

    Был взят небольшой объём данных, чтобы показать прогноз модели. Из результатов видно, что ошибка модели невелика.

    Как и говорилось выше, чаще всего встречаются классы 2 и 6. Соответственно, модель меньше всего ошибается именно в них.

    В сухом остатке

    Мы смогли избавить модель от переобучения путём увеличения dropout, после чего более высокие результаты были достигнуты за счёт увеличения количества нейронов и эпох. В конечном счёте общая точность предсказания модели по всем классам продуктов составляет чуть больше 0,81, что характеризует её качество. Соответственно, теперь эту модель можно использовать для решения задачи многоклассовой классификации. Плюс в том, что структура является универсальной, так что её можно использовать при решении задач с применением нейронных сетей.

    • машинное обучение
    • нейросети
    • научно-популярное
    • искуственный интеллект
    • ai
    • Блог компании Сбер
    • Машинное обучение
    • Научно-популярное
    • Искусственный интеллект

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

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