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

Как сделать обучающийся искусственный интеллект на python

  • автор:

Искусственный интеллект на Python для детей

Искусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детейИскусственный интеллект на Python для детей Искусственный интеллект на Python для детей

Подходит ли создание искусственного интеллекта для детей?

То, что родителям все еще кажется фантастикой, для для сегодняшних детей привычно. Многие с детства отдают приказы умным помощникам и пользуются рекомендательными системами видеохостингов. Кто-то с 9 лет занимаются программированием дополнительно к школьным предметам. Существует много курсов изучения Python для детей, и кто-то из подростков уже создавал свой несложный ИИ или несложную для детей нейросеть. Это люди будущего.

Искусственный интеллект на Python с использованием TensorFlow и Keras

Искусственный интеллект и машинное обучение становятся все более востребованными в современном мире. Многие компании и стартапы активно внедряют технологии искусственного интеллекта для решения бизнес-задач и оптимизации процессов.

Одним из ключевых инструментов для реализации нейро-сетевых архитектур и алгоритмов глубокого обучения является язык программирования Python. Благодаря наличию мощных библиотек, таких как TensorFlow и Keras, создание и обучение нейронных сетей на Python стало достаточно простым.

TensorFlow — это библиотека для машинного обучения, разработанная компанией Google. Она позволяет определять, тренировать и запускать нейронные сети различных архитектур. Keras — библиотека глубокого обучения высокого уровня, может использовать TensorFlow в качестве бэкенда. Keras упрощает создание моделей нейросетей благодаря удобному API.

Цель этой статьи — познакомить читателей с основными принципами глубокого обучения, а также возможностями библиотек TensorFlow и Keras для создания и обучения нейронных сетей на Python. Мы рассмотрим базовые концепции, этапы обучения моделей, а также практические кейсы использования TensorFlow и Keras для решения задач классификации, распознавания и анализа данных.

Изучив эту статью, читатели получат представление о том, как при помощи Python и рассматриваемых библиотек можно создавать эффективные модели искусственного интеллекта

Основные концепции

Что такое нейронные сети и глубокое обучение.

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

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

Такая структура позволяет нейросетям эффективно работать с неструктурированными данными — изображениями, текстом, звуком. Нейронные сети способны анализировать входные данные и находить в них сложные зависимости и паттерны.

Глубокое обучение — это метод машинного обучения на основе искусственных нейронных сетей с большим количеством слоев. Благодаря многослойной структуре, такие сети могут строить более сложные модели и находить скрытые зависимости в данных.

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

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

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

Обучение с подкреплением и обучение с учителем

Обучение с подкреплением (reinforcement learning) — это метод обучения нейросетей, при котором модель должна самостоятельно на практике понять, какие действия приводят к позитивному результату, а какие — к негативному.

Сеть взаимодействует с окружающей средой, выбирает и выполняет различные действия, и получает немедленное «подкрепление» в виде награды или штрафа за эти действия. Цель — максимизировать получаемую суммарную награду.

Например, так обучаются сети для игр, управления роботами, торговых стратегий. Сеть сама исследует все возможные варианты и учится выбирать оптимальные ходы.

Обучение с учителем (supervised learning) подразумевает наличие обучающей выборки с правильными ответами. Сеть обучается предсказывать ответы для новых примеров на основе известных данных.

Этот метод используется в задачах классификации, регрессии, прогнозирования. Сеть получает примеры объектов с «метками» (digits dataset) и учится распознавать эти объекты.

Использование TensorFlow в Python

Установка и импорт TensorFlow

Чтобы начать использовать TensorFlow в Python, нужно установить эту библиотеку. Это можно сделать с помощью менеджера пакетов pip:

pip install tensorflow 

После этого TensorFlow можно импортировать в коде Python:

import tensorflow as tf 

TensorFlow имеет высокоуровневый API (tf.keras) и низкоуровневый API. В данной статье мы будем использовать низкоуровневый API для большего понимания принципов работы.

Импортируем основные компоненты:

import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers 

Теперь TensorFlow доступен для использования в нашем коде на Python для создания и обучения нейронных сетей.

Создание и обучение простой нейронной сети

Давайте создадим и обучим простую полно-связную нейронную сеть на TensorFlow для решения задачи классификации.

Сначала определяем архитектуру — последовательность слоев. Создадим 3 полно-связных слоя с 64, 32 и 10 нейронами:

model = tf.keras.Sequential() model.add(tf.keras.layers.Dense(64, activation='relu')) model.add(tf.keras.layers.Dense(32, activation='relu')) model.add(tf.keras.layers.Dense(10)) 

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

model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) 

Далее обучим сеть на тренировочных данных:

model.fit(train_images, train_labels, epochs=5) 

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

Использование различных слоев и функций

TensorFlow предоставляет большой набор готовых слоев и функций для построения нейронных сетей:

  • Полносвязные слои (Dense) — основа для создания полносвязных сетей
  • Сверточные слои (Conv2D, Conv3D) — используются в сверточных сетях для работы с изображениями
  • Пулинг слои (MaxPooling2D) — применяются после сверточных для снижения размерности
  • Рекуррентные слои (LSTM, GRU) — для сетей RNN и обработки последовательностей
  • Слои нормализации (BatchNormalization) — для нормализации активаций в сети
  • Функции активации (ReLU, LeakyReLU, Sigmoid, Softmax и др.) — добавляют нелинейность
  • Функции потерь (Losses) — MSE, CrossEntropy, SparseCategoricalCrossentropy и др.
  • Оптимизаторы (Optimizers) — Adam, SGD, RMSprop и др. для обновления весов

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

Визуализация работы нейросети в TensorFlow

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

TensorBoard — позволяет строить графики потерь, метрик, весов нейронов в процессе обучения:

tensorboard = TensorBoard(log_dir="logs") model.fit(data, labels, epochs=10, callbacks=[tensorboard]) 

TensorBoard запускается в браузере и отображает графики из логов обучения.

Кроме того, можно визуализировать активации конкретных нейронов при обработке входных данных с помощью Keras:

layer = model.layers[2] activations = layer.activations import matplotlib.pyplot as plt plt.imshow(activations[0][0. ], cmap='viridis') 

Это помогает понимать, на что именно реагируют нейроны в разных слоях сети.

Визуализация значительно упрощает отладку и оптимизацию нейронных сетей в TensorFlow.

Использование Keras в Python

Установка и импорт Keras

Keras — это высокоуровневая нейро-сетевая библиотека для Python, которая может использовать TensorFlow в качестве бэкенда. Установить Keras можно через pip:

pip install keras 
import keras from keras import models from keras import layers 

Keras имеет простой и понятный API для быстрой разработки нейронных сетей.

В Keras есть два основных способа создания моделей:

  • Последовательный (Sequential) — для линейных стеков слоев
  • Функциональный (Functional) — для произвольных графов слоев

Рассмотрим использование каждого из них.

Создание модели Sequential в Keras

Чтобы создать простую линейную модель в Keras, используется API Sequential:

model = keras.Sequential() model.add(keras.layers.Dense(32, activation='relu')) model.add(keras.layers.Dense(10, activation='softmax')) 

Слои просто добавляются в модель последовательно один за другим с помощью метода add(). Это удобный способ быстро создать полносвязную или сверточную сеть.

Далее модель компилируется и обучается стандартными методами:

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(x_train, y_train, batch_size=64, epochs=5) 

Таким образом, с помощью простого Sequential API в Keras можно определять и обучать нейронные сети всего несколькими строками кода.

Создание модели Functional в Keras

Для создания более сложных сетевых архитектур в Keras используется функциональный API:

inputs = keras.Input(shape=(32,)) x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) outputs = layers.Dense(10, activation='softmax')(x) model = keras.Model(inputs=inputs, outputs=outputs) 

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

Это позволяет создавать разветвленные сети, остаточные связи, многовходовые и многовыходные модели.

Например, можно соединить две разные модели Sequential в одну большую модель Functional.

Такой API дает гибкость в создании нейро-сетевых архитектур произвольной сложности в Keras.

Преимущества Keras как «обертки» над TensorFlow

Keras имеет ряд преимуществ по сравнению с TensorFlow:

  • Более простой и интуитивный API для разработки моделей
  • Меньше кода для решения типовых задач
  • Встроенные функции для обучения, оптимизации, оценки моделей
  • Возможность быстрого прототипирования и итераций
  • Совместимость с TensorFlow как низкоуровневым бэкендом

Но при этом Keras сохраняет гибкость TensorFlow для разработки сложных архитектур.

Примеры обучения разных типов нейросетей в Keras:

  • Полносвязные для классификации текста или чисел
  • Сверточные для обработки изображений
  • Рекуррентные (LSTM, GRU) для текста и временных рядов
  • Автокодировщики для снижения размерности
  • Сети на основе GAN для генерации контента

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

Применение на практике

Решение задачи классификации изображений с TensorFlow

Рассмотрим применение TensorFlow для решения классической задачи компьютерного зрения — классификации изображений.

В качестве данных возьмем один из популярных датасетов — MNIST, содержащий 70 000 изображений рукописных цифр 0-9.

Построим простую сверточную нейронную сеть в TensorFlow:

  • Слой свертки для извлечения признаков
  • Пулинг слой для снижения размерности
  • Полносвязный слой для классификации
model = tf.keras.Sequential() model.add(tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28, 28, 1))) model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2))) model.add(tf.keras.layers.Flatten()) model.add(tf.keras.layers.Dense(10, activation='softmax')) 

Обучим модель на данных MNIST:

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(train_images, train_labels, epochs=5, batch_size=64) 

Теперь сеть готова классифицировать рукописные цифры с достаточно высокой точностью!

Классификация изображений — один из самых распространенных примеров применения нейронных сетей на практике с помощью TensorFlow.

Анализ временных рядов с помощью RNN

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

Рассмотрим применение RNN на TensorFlow для прогнозирования временного ряда.

Построим простую RNN-сеть с использованием lstm-слоев:

model = tf.keras.Sequential() model.add(tf.keras.layers.LSTM(128, input_shape=(None, 1))) model.add(tf.keras.layers.Dense(1)) model.compile(loss='mae', optimizer='adam') 

Обучим сеть на данных о ценах акций за несколько лет для прогноза цены через месяц:

model.fit(X_train, y_train, epochs=10) 

Теперь используем обученную RNN для предсказания цены на месяц на основе предыдущих данных:

prediction = model.predict(X_test) 

LSTM-сети отлично подходят для многих задач анализа временных рядов: прогнозирование, выявление аномалий, классификация и др.

Заключение

Резюме возможностей глубокого обучения в Python с TensorFlow

В этой статье мы рассмотрели основные возможности библиотеки TensorFlow для создания и обучения нейронных сетей с помощью Python.

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

Благодаря высокоуровневым и низкоуровневым API можно как быстро прототипировать модели, так и полностью контролировать архитектуру и обучение сетей.

Возможности визуализации в TensorFlow упрощают отладку, мониторинг и оптимизацию нейронных сетей.

Рекомендации по использованию TensorFlow и Keras

TensorFlow и Keras — отличный выбор для создания проектов машинного обучения и глубоких нейронных сетей на Python. Вот несколько рекомендаций по использованию этих инструментов:

  • Начинать лучше с Keras как высокоуровневого и простого в освоении API. Создавать модели с помощью Sequential и Functional API.
  • Постепенно изучать возможности низкоуровневого TensorFlow, чтобы расширять гибкость и контроль при разработке сетей.
  • Использовать предобученные модели (VGG, ResNet, Inception и др.) как базу или для transfer learning при решении практических задач.
  • Применять разные архитектуры: сверточные сети для изображений, RNN и LSTM для последовательных данных.
  • Использовать вспомогательные техники: dropout, batch normalization для обучения больших сетей.
  • Визуализировать процесс обучения сетей с помощью TensorBoard.
  • Разбивать данные на наборы: обучающий, валидационный, тестовый для правильной оценки моделей.
  • Подбирать гиперпараметры (скорость обучения, размер батчей, эпохи) для оптимизации обучения.

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

Искусственный интеллект на Python и Tensorflow

Искусственный интеллект на Python и Tensorflow

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

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

Что будет в нашей программе?

Наш искусственный интеллект не будет распознавать все объекты, по типу: машин, других животных, людей и тому прочее. Не будет он это делать по одной причине. Мы в качестве датасета или же, другими словами, набора данных для тренировки – будем использовать датасет от компании Microsoft. В датасете у них собрано более 25 000 фотографий котов и собачек, что даст нам возможность натренировать правильные весы для распознавания наших собственных фото.

Мы не будем сами искать варианты для обучения нейронной сети и на это есть два фактора:

  1. В этом нет смысла, так как для подобных задач, зачастую, уже есть различные датасеты с подготовленными данными, которые можно использовать.
  2. У нас уйдет слишком много времени и сил на тренировку своей нейронной сети. Только представьте, нам потребуется найти и произвести обучение на тысячах фотографиях. Это не только очень сложно, но и дорого.

По этой причине для нашей программы мы воспользуемся готовым набором данных.

Какие библиотеки нам потребуются?

В прошлой статье мы использовали лишь одну библиотеку – numpy . Без этой библиотеки нам не обойтись и в этот раз.

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

По причине того, что нейронные сети – это математика, массивы и наборы данных, то без numpy – не обойтись.

Также мы будем использовать библиотеку Tensorflow. Она создана компанией Google и служит для решения задач построения и тренировки нейронной сети. За счет неё процесс обучение нейронки немного проще, нежели при написании с использованием только numpy.

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

Среда разработки

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

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

Такой принцип существенно экономит время и по этой причине мы и будем использовать сервис Google Colab.

Создание проекта

Полная разработка проекта показывается в видео. Вы можете просмотреть его ниже:

Полезные ссылки:

  • Сервис Google Colab ;
  • Распознавание объектов на видео .

Код для реализации проекта из видео:

# Импорт библиотек и классов import numpy as np import tensorflow as tf import tensorflow_datasets as tfds from tensorflow.keras.preprocessing.image import load_img, img_to_array from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout import matplotlib.pyplot as plt from google.colab import files # Подгрузка датасета от Microsoft train, _ = tfds.load('cats_vs_dogs', split=['train[:100%]'], with_info=True, as_supervised=True) # Функция для изменения размеров изображений SIZE = (224, 224) def resize_image(img, label): img = tf.cast(img, tf.float32) img = tf.image.resize(img, SIZE) img /= 255.0 return img, label # Уменьшаем размеры всех изображений, полученных из датасета train_resized = train[0].map(resize_image) train_batches = train_resized.shuffle(1000).batch(16) # Создание основного слоя для создания модели base_layers = tf.keras.applications.MobileNetV2(input_shape=(SIZE[0], SIZE[1], 3), include_top=False) # Создание модели нейронной сети model = tf.keras.Sequential([ base_layers, GlobalAveragePooling2D(), Dropout(0.2), Dense(1) ]) model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=['accuracy']) # Обучение нейронной сети (наши картинки, одна итерация обучения) model.fit(train_batches, epochs=1) # Функция для подгрузки изображений files.upload() # Сюда укажите названия подгруженных изображений images = [] # Перебираем все изображения и даем нейронке шанс определить что находиться на фото for i in images: img = load_img(i) img_array = img_to_array(img) img_resized, _ = resize_image(img_array, _) img_expended = np.expand_dims(img_resized, axis=0) prediction = model.predict(img_expended) plt.figure() plt.imshow(img) label = 'Собачка' if prediction > 0 else 'Кошка' plt.title('<>'.format(label))

Изучение программирования

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

Больше интересных новостей

Худшие (и при этом самые популярные) пароли: Топ-10 за 10 лет

Худшие (и при этом самые популярные) пароли: Топ-10 за 10 лет

Сквозное шифрование: что это и зачем оно нужно

Сквозное шифрование: что это и зачем оно нужно

10 популярных языков программирования

10 популярных языков программирования

Искусственный интеллект на Python и Tensorflow

Искусственный интеллект на Python и Tensorflow

Комментарии (1)

DWilight 28 июля 2023 в 11:27

Python AI: как построить нейронную сеть и делать прогнозы

Проще говоря, цель использования ИИ — заставить компьютеры думать так же, как люди. Это может показаться чем-то новым, но эта область родилась в 1950-х годах.

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

Машинное обучение (ML) и глубокое обучение (DL) также являются подходами к решению проблем. Разница между этими методами и скриптом Python заключается в том, что ML и DL используют обучающие данные вместо жестко запрограммированных правил, но все они могут использоваться для решения задач с использованием ИИ. В следующих разделах вы узнаете больше о том, что отличает эти два метода.

Машинное обучение

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

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

Рабочий процесс для обучения модели машинного обучения

Комбинация обучающих данных с алгоритмом машинного обучения создает модель. Затем с помощью этой модели вы можете делать прогнозы для новых данных.

Примечание. scikit-learn — это популярная библиотека машинного обучения Python, которая предоставляет множество алгоритмов обучения с учителем и без учителя. Чтобы узнать больше об этом, ознакомьтесь с Разделение набора данных с помощью train_test_split() от scikit-learn .

Цель задач контролируемого обучения — делать прогнозы для новых, невидимых данных. Для этого вы предполагаете, что эти невидимые данные следуют распределению вероятностей, аналогичному распределению обучающего набора данных. Если в будущем это распределение изменится, вам нужно снова обучить свою модель, используя новый набор обучающих данных.

Разработка функций

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

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

Примером техники разработки признаков является лемматизация , при которой вы удаляете склонение слов в предложении. Например, флективные формы глагола «смотреть», такие как «часы», «наблюдать» и «наблюдать», будут сокращены до их леммы или базовой формы: «смотреть».

Если вы используете массивы для хранения каждого слова корпуса, то применяя лемматизацию, вы получаете менее разреженную матрицу. Это может повысить производительность некоторых алгоритмов машинного обучения. На следующем изображении представлен процесс лемматизации и представления с использованием модели мешка слов :

Создание функций с использованием модели мешка слов

Во-первых, флективная форма каждого слова сводится к его лемме. Затем подсчитывается количество вхождений этого слова. Результатом является массив, содержащий количество вхождений каждого слова в тексте.

Глубокое обучение

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

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

Нейронные сети: основные понятия

Нейронная сеть — это система, которая учится делать прогнозы, выполняя следующие шаги:

  1. Получение входных данных
  2. Делаем прогноз
  3. Сравнение прогноза с желаемым результатом
  4. Настройка его внутреннего состояния для правильного прогнозирования в следующий раз

Векторы , слои и линейная регрессия — вот некоторые из строительных блоков нейронных сетей. Данные хранятся в виде векторов, а в Python вы храните эти векторы в массивах . Каждый уровень преобразует данные, поступающие с предыдущего уровня. Вы можете думать о каждом слое как о шаге разработки признаков, потому что каждый слой извлекает некоторое представление данных, которые были получены ранее.

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

На изображении ниже вы можете увидеть пример сетевой архитектуры с двумя уровнями:

Нейронная сеть с двумя слоями

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

Процесс обучения нейронной сети

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

Вот шаги для попытки попасть в центр мишени для дартс:

Шаги, чтобы попасть в центр дартс

Обратите внимание, что вы продолжаете оценивать ошибку, наблюдая, куда приземлился дротик (шаг 2). Вы продолжаете, пока, наконец, не попадете в центр мишени.

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

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

Векторы и веса

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

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

Модель линейной регрессии

Регрессия используется, когда вам нужно оценить взаимосвязь между зависимой переменной и двумя или более независимыми переменными . Линейная регрессия — это метод, применяемый, когда вы аппроксимируете связь между переменными как линейную. Метод восходит к девятнадцатому веку и является самым популярным методом регрессии.

Примечание. Линейная связь — это связь, в которой существует прямая связь между независимой переменной и зависимой переменной.

Смоделировав взаимосвязь между переменными как линейную, вы можете выразить зависимую переменную как взвешенную сумму независимых переменных. Таким образом, каждая независимая переменная будет умножена на вектор с именем weight . Помимо весов и независимых переменных, вы также добавляете еще один вектор: смещение . Он устанавливает результат, когда все остальные независимые переменные равны нулю.

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

price = (weights_area * area) + (weights_age * age) + bias

В приведенном выше примере есть два веса: weights_area и weights_age . Процесс обучения состоит из корректировки весов и смещения, чтобы модель могла предсказать правильное значение цены. Для этого вам нужно вычислить ошибку прогноза и соответствующим образом обновить веса.

Это основы того, как работает механизм нейронной сети. Теперь пришло время посмотреть, как применять эти концепции с помощью Python.

Python AI: начинаем строить свою первую нейронную сеть

Первым шагом в построении нейронной сети является создание выходных данных из входных данных. Вы сделаете это, создав взвешенную сумму переменных. Первое, что вам нужно сделать, это представить входные данные с помощью Python и NumPy .

Обертывание входных данных нейронной сети с помощью NumPy

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

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

Три вектора в декартовой координатной плоскости

weights_2 больше похож на входной вектор, поскольку он указывает в том же направлении, и величина также аналогична. Так как же определить, какие векторы похожи с помощью Python?

Во-первых, вы определяете три вектора, один для ввода и два других для весов. Затем вы вычисляете, насколько похожи input_vector и weights_1 . Для этого вы примените скалярное произведение . Поскольку все векторы являются двумерными векторами, вот шаги для этого:

  1. Умножьте первый индекс input_vector на первый индекс weights_1 .
  2. Умножьте второй индекс input_vector на второй индекс weights_2 .
  3. Суммируйте результаты обоих умножений.

Вы можете использовать консоль IPython или блокнот Jupyter , чтобы следовать инструкциям. Хорошей практикой является создание новой виртуальной среды каждый раз, когда вы начинаете новый проект Python, поэтому вы должны сделать это в первую очередь. venv поставляется с Python версии 3.3 и выше и удобен для создания виртуальной среды.

Продолжение статьи будет позже.

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

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