AI с Python - Краткое руководство

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

Раздел компьютерных наук под названием «Искусственный интеллект» занимается созданием компьютеров или машин, столь же умных, как люди.

Базовая концепция искусственного интеллекта (ИИ)

По словам отца искусственного интеллекта Джона Маккарти, это «наука и техника создания интеллектуальных машин, особенно интеллектуальных компьютерных программ».

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

Эксплуатируя мощь компьютерных систем и любопытство человека, он задался вопросом: «Может ли машина думать и вести себя, как люди?»

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

Необходимость изучения ИИ

Как мы знаем, ИИ стремится создавать машины, разумные, как люди. У нас есть множество причин изучать ИИ. Причины следующие -

ИИ может учиться через данные

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

ИИ может научить себя

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

ИИ может отвечать в режиме реального времени

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

ИИ достигает точности

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

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

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

Понимание интеллекта

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

Что такое интеллект?

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

Типы интеллекта

По словам американского психолога-психолога Ховарда Гарднера, интеллект бывает многогранным:

Старший Нет	Интеллект и описание	пример
1	Linguistic intelligence Способность говорить, распознавать и использовать механизмы фонологии (звуки речи), синтаксиса (грамматики) и семантики (значения).	Рассказчики, Ораторы
2	Musical intelligence Способность создавать, общаться и понимать значения звука, понимание высоты звука и ритма.	Музыканты, певцы, композиторы
3	Logical-mathematical intelligence Способность использовать и понимать отношения при отсутствии действий или объектов. Это также способность понимать сложные и абстрактные идеи.	Математики, ученые
4	Spatial intelligence Способность воспринимать визуальную или пространственную информацию, изменять ее и воссоздавать визуальные образы без привязки к объектам, создавать трехмерные изображения, а также перемещать и вращать их.	Картографы, Космонавты, Физики
5	Bodily-Kinesthetic intelligence Способность использовать все или часть тела для решения проблем или создания изделий, контроля тонкой и грубой моторики и манипулирования объектами.	Игроки, танцоры
6	Intra-personal intelligence Способность различать собственные чувства, намерения и мотивации.	Гаутама Будда
7	Interpersonal intelligence Способность распознавать и различать чувства, убеждения и намерения других людей.	Массовые коммуникаторы, интервьюеры

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

Из чего состоит интеллект?

Интеллект нематериален. Он состоит из -

• Reasoning
• Learning
• Решение проблем
• Perception
• Лингвистический интеллект

Давайте кратко рассмотрим все компоненты -

Рассуждение

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

Индуктивное мышление	Дедуктивное мышление
Он проводит конкретные наблюдения, чтобы сделать общие заявления.	Он начинается с общего утверждения и исследует возможности для достижения конкретного логического вывода.
Даже если в утверждении все предпосылки истинны, индуктивное рассуждение позволяет сделать вывод ложным.	Если что-то верно для класса вещей в целом, это также верно для всех членов этого класса.
Example - «Нита - учитель. Нита прилежна. Поэтому все учителя прилежны».	Example - «Все женщины старше 60 лет - бабушки. Шалини 65 лет. Следовательно, Шалини - бабушка».

Обучение - l

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

Слуховое обучение

Это обучение, слушая и слушая. Например, студенты слушают записанные аудиолекции.

Эпизодическое обучение

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

Моторное обучение

Это обучение за счет точного движения мышц. Например, собирать предметы, писать и т. Д.

Наблюдательное обучение

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

Перцептивное обучение

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

Реляционное обучение

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

• Spatial Learning - Это обучение с помощью визуальных стимулов, таких как изображения, цвета, карты и т. Д. Например, человек может создать дорожную карту в уме, прежде чем фактически следовать по дороге.

• Stimulus-Response Learning- Это обучение определенному поведению при наличии определенного стимула. Например, собака поднимает ухо, услышав дверной звонок.

Решение проблем

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

Решение проблем также включает decision making, который представляет собой процесс выбора наиболее подходящей альтернативы из множества альтернатив для достижения желаемой цели.

Восприятие

Это процесс получения, интерпретации, отбора и организации сенсорной информации.

Восприятие предполагает sensing. У людей восприятию помогают органы чувств. В области искусственного интеллекта механизм восприятия объединяет данные, полученные датчиками, воедино.

Лингвистический интеллект

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

Что задействовано в ИИ

Искусственный интеллект - обширная область исследований. Эта область исследования помогает находить решения реальных проблем.

Давайте теперь посмотрим на различные области изучения ИИ -

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

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

Логика

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

Поиск

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

Искусственные нейронные сети

Это сеть эффективных вычислительных систем, центральная тема которой заимствована из аналогии с биологическими нейронными сетями. ИНС можно использовать в робототехнике, распознавании речи, обработке речи и т. Д.

Генетический алгоритм

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

Представление знаний

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

Применение ИИ

В этом разделе мы увидим различные поля, поддерживаемые AI -

Игры

ИИ играет решающую роль в стратегических играх, таких как шахматы, покер, крестики-нолики и т. Д., Где машина может продумывать большое количество возможных позиций на основе эвристических знаний.

Обработка естественного языка

Можно взаимодействовать с компьютером, который понимает естественный язык, на котором говорят люди.

Экспертные системы

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

Системы зрения

Эти системы понимают, интерпретируют и воспринимают визуальный ввод на компьютере. Например,

• Самолет-шпион делает фотографии, которые используются для определения пространственной информации или карты местности.

• Врачи используют клиническую экспертную систему для диагностики пациента.

• Полиция использует компьютерное программное обеспечение, которое может распознать лицо преступника по сохраненному портрету, сделанному судебно-медицинским экспертом.

Распознавание речи

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

Распознавание почерка

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

Интеллектуальные роботы

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

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

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

Агент и среда

В этом разделе мы сосредоточимся на агенте и среде и на том, как они помогают в искусственном интеллекте.

Агент

Агент - это все, что может воспринимать окружающую среду с помощью датчиков и воздействовать на нее с помощью эффекторов.

• А human agent имеет органы чувств, такие как глаза, уши, нос, язык и кожу, параллельные датчикам, и другие органы, такие как руки, ноги, рот, для эффекторов.

• А robotic agent заменяет камеры и инфракрасные дальномеры для датчиков, а также различные двигатели и исполнительные механизмы для эффекторов.

• А software agent закодировал битовые строки как свои программы и действия.

Окружающая обстановка

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

Напротив, некоторые программные агенты (программные роботы или программные боты) существуют в обширных неограниченных доменах программных ботов. Симулятор имеетvery detailed, complex environment. Программный агент должен выбирать из длинного набора действий в реальном времени. Софт-бот предназначен для сканирования онлайн-предпочтений клиента и показывает покупателю интересные вещи, работает вreal а также artificial окружающая обстановка.

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

Почему Python для ИИ

Искусственный интеллект считается новейшей технологией будущего. Уже сейчас на него подано несколько приложений. В связи с этим этим интересуются многие компании и исследователи. Но главный вопрос, который здесь возникает, заключается в том, на каком языке программирования можно разрабатывать эти приложения ИИ? Существуют различные языки программирования, такие как Lisp, Prolog, C ++, Java и Python, которые можно использовать для разработки приложений ИИ. Среди них язык программирования Python приобретает огромную популярность по следующим причинам:

Простой синтаксис и меньше кода

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

Встроенные библиотеки для проектов AI

Основным преимуществом использования Python для ИИ является то, что он поставляется со встроенными библиотеками. В Python есть библиотеки практически для всех проектов AI. Например,NumPy, SciPy, matplotlib, nltk, SimpleAI - это некоторые из важных встроенных библиотек Python.

• Open source- Python - это язык программирования с открытым исходным кодом. Это делает его широко популярным в сообществе.

• Can be used for broad range of programming- Python можно использовать для широкого круга задач программирования, таких как небольшой сценарий оболочки для корпоративных веб-приложений. Это еще одна причина, по которой Python подходит для проектов AI.

Особенности Python

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

• Easy-to-learn- Python имеет несколько ключевых слов, простую структуру и четко определенный синтаксис. Это позволяет студенту быстро овладеть языком.

• Easy-to-read - Код Python более четко определен и виден глазам.

• Easy-to-maintain - Исходный код Python довольно прост в обслуживании.

• A broad standard library - Большая часть библиотеки Python очень портативна и кроссплатформенна, совместима с UNIX, Windows и Macintosh.

• Interactive Mode - Python поддерживает интерактивный режим, который позволяет интерактивное тестирование и отладку фрагментов кода.

• Portable - Python может работать на самых разных аппаратных платформах и имеет одинаковый интерфейс на всех платформах.

• Extendable- Мы можем добавлять в интерпретатор Python низкоуровневые модули. Эти модули позволяют программистам добавлять или настраивать свои инструменты для повышения эффективности.

• Databases - Python предоставляет интерфейсы для всех основных коммерческих баз данных.

• GUI Programming - Python поддерживает приложения с графическим интерфейсом пользователя, которые можно создавать и переносить во многие системные вызовы, библиотеки и системы Windows, такие как Windows MFC, Macintosh и систему X Window в Unix.

• Scalable - Python обеспечивает лучшую структуру и поддержку больших программ, чем сценарии оболочки.

Важные особенности Python

Давайте теперь рассмотрим следующие важные особенности Python -

• Он поддерживает методы функционального и структурного программирования, а также ООП.

• Он может использоваться как язык сценариев или может быть скомпилирован в байт-код для создания больших приложений.

• Он предоставляет динамические типы данных очень высокого уровня и поддерживает проверку динамических типов.

• Он поддерживает автоматический сбор мусора.

• Его можно легко интегрировать с C, C ++, COM, ActiveX, CORBA и Java.

Установка Python

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

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

Вот краткий обзор установки Python на различных платформах -

Установка Unix и Linux

Выполните следующие действия, чтобы установить Python на машину Unix / Linux.

• Откройте веб-браузер и перейдите в https://www.python.org/downloads

• Перейдите по ссылке, чтобы загрузить заархивированный исходный код, доступный для Unix / Linux.

• Скачайте и распакуйте файлы.

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

• запустить ./configure скрипт

• make

• сделать установку

Это устанавливает Python в стандартное расположение / usr / local / bin и его библиотеки в / usr / local / lib / pythonXX, где XX - это версия Python.

Установка Windows

Выполните следующие действия, чтобы установить Python на компьютер с Windows.

• Откройте веб-браузер и перейдите в https://www.python.org/downloads

• Перейдите по ссылке на файл python-XYZ .msi установщика Windows, где XYZ - это версия, которую необходимо установить.

• Чтобы использовать этот установщик python-XYZ .msi, система Windows должна поддерживать Microsoft Installer 2.0. Сохраните файл установщика на локальном компьютере, а затем запустите его, чтобы узнать, поддерживает ли ваш компьютер MSI.

• Запускаем скачанный файл. Это вызывает мастер установки Python, который действительно прост в использовании. Просто примите настройки по умолчанию и дождитесь завершения установки.

Установка Macintosh

Если у вас Mac OS X, рекомендуется использовать Homebrew для установки Python 3. Это отличный установщик пакетов для Mac OS X, и он действительно прост в использовании. Если у вас нет Homebrew, вы можете установить его с помощью следующей команды -

$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"

Мы можем обновить диспетчер пакетов с помощью команды ниже -

$ brew update

Теперь выполните следующую команду, чтобы установить Python3 в вашей системе -

$ brew install python3

Настройка PATH

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

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

Переменная пути называется PATH в Unix или Path в Windows (Unix чувствителен к регистру; Windows - нет).

В Mac OS установщик обрабатывает сведения о пути. Чтобы вызвать интерпретатор Python из любого конкретного каталога, вы должны добавить каталог Python в свой путь.

Установка пути в Unix / Linux

Чтобы добавить каталог Python к пути для определенного сеанса в Unix -

• В оболочке csh

  Тип setenv PATH "$PATH:/usr/local/bin/python" и нажмите Enter.

• В оболочке bash (Linux)

  Тип export ATH = "$PATH:/usr/local/bin/python" и нажмите Enter.

• В оболочке sh или ksh

  Тип PATH = "$PATH:/usr/local/bin/python" и нажмите Enter.

Note - / usr / local / bin / python - это путь к каталогу Python.

Установка пути в Windows

Чтобы добавить каталог Python к пути для определенного сеанса в Windows -

• At the command prompt - тип path %path%;C:\Python и нажмите Enter.

Note - C: \ Python - это путь к каталогу Python.

Запуск Python

Давайте теперь посмотрим, как запускать Python. Способы описаны ниже -

Интерактивный переводчик

Мы можем запустить Python из Unix, DOS или любой другой системы, которая предоставляет вам интерпретатор командной строки или окно оболочки.

• Войти python в командной строке.

• Начните писать прямо сейчас в интерактивном интерпретаторе.

$python # Unix/Linux

или же

python% # Unix/Linux

или же

C:> python # Windows/DOS

Вот список всех доступных параметров командной строки -

S.No.	Вариант и описание
1	-d Он обеспечивает вывод отладки.
2	-o Он генерирует оптимизированный байт-код (в результате получаются файлы .pyo).
3	-S Не запускайте сайт импорта для поиска путей Python при запуске.
4	-v Подробный вывод (подробная трассировка операторов импорта).
5	-x Отключает встроенные исключения на основе классов (просто используйте строки); устарело, начиная с версии 1.6.
6	-c cmd Запускает сценарий Python, отправленный в виде строки cmd.
7	File Запустить скрипт Python из заданного файла.

Скрипт из командной строки

Сценарий Python может быть выполнен в командной строке, вызвав интерпретатор в вашем приложении, как показано ниже:

$python script.py # Unix/Linux

или же,

python% script.py # Unix/Linux

или же,

C:> python script.py # Windows/DOS

Note - Убедитесь, что режим разрешений файла разрешает выполнение.

Интегрированная среда разработки

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

• Unix - IDLE - это самая первая Unix IDE для Python.

• Windows - PythonWin - это первый интерфейс Windows для Python, представляющий собой IDE с графическим интерфейсом.

• Macintosh - Версия Python для Macintosh вместе с IDLE IDE доступна с основного веб-сайта и может быть загружена в виде файлов MacBinary или BinHex'd.

Если вы не можете правильно настроить среду, обратитесь за помощью к системному администратору. Убедитесь, что среда Python правильно настроена и работает нормально.

Мы также можем использовать другую платформу Python под названием Anaconda. Он включает сотни популярных пакетов для науки о данных, а также пакет conda и диспетчер виртуальной среды для Windows, Linux и MacOS. Вы можете скачать его в соответствии с вашей операционной системой по ссылкеhttps://www.anaconda.com/download/.

Для этого урока мы используем версию Python 3.6.3 в MS Windows.

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

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

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

Типы машинного обучения (ML)

Алгоритмы машинного обучения помогают компьютерной системе учиться без явного программирования. Эти алгоритмы делятся на контролируемые и неконтролируемые. Давайте теперь посмотрим несколько алгоритмов -

Алгоритмы машинного обучения с учителем

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

Предположим, у нас есть входные переменные x и выходная переменная y и мы применили алгоритм для изучения функции сопоставления от входа к выходу, например -

Y = f(x)

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

В основном контролируемые проблемы наклона можно разделить на следующие два типа проблем:

• Classification - Проблема называется проблемой классификации, когда у нас есть категоризированный вывод, такой как «черный», «обучение», «не обучение» и т. Д.

• Regression - Проблема называется проблемой регрессии, когда у нас есть реальные выходные данные, такие как «расстояние», «килограмм» и т. Д.

Дерево решений, случайный лес, knn, логистическая регрессия - это примеры контролируемых алгоритмов машинного обучения.

Алгоритмы неконтролируемого машинного обучения

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

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

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

Проблемы обучения без учителя можно разделить на следующие два типа проблем:

• Clustering- В задачах кластеризации нам нужно обнаружить присущие группировки данных. Например, группировка клиентов по их покупательскому поведению.

• Association- Проблема называется проблемой ассоциации, потому что такого рода проблемы требуют обнаружения правил, описывающих большие части наших данных. Например, поиск клиентов, которые покупают обаx и y.

K-средство для кластеризации, алгоритм Apriori для ассоциации - это примеры алгоритмов машинного обучения без учителя.

Алгоритмы машинного обучения с подкреплением

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

Наиболее распространенные алгоритмы машинного обучения

В этом разделе мы узнаем о наиболее распространенных алгоритмах машинного обучения. Алгоритмы описаны ниже -

Линейная регрессия

Это один из самых известных алгоритмов в статистике и машинном обучении.

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

Типы линейной регрессии

Линейная регрессия бывает следующих двух типов -

• Simple linear regression - Алгоритм линейной регрессии называется простой линейной регрессией, если он имеет только одну независимую переменную.

• Multiple linear regression - Алгоритм линейной регрессии называется множественной линейной регрессией, если он имеет более одной независимой переменной.

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

Логистическая регрессия

Это алгоритм классификации, также известный как logit регресс.

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

Древо решений

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

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

Машина опорных векторов (SVM)

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

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

Наивный байесовский

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

$$ P \ left (\ frac {A} {B} \ right) = \ frac {P \ left (\ frac {B} {A} \ right) P \ left (A \ right)} {P \ left ( B \ right)} $$

Модель Наивного Байеса проста в построении и особенно полезна для больших наборов данных.

K-Ближайшие соседи (KNN)

Он используется как для классификации, так и для регрессии проблем. Он широко используется для решения задач классификации. Основная идея этого алгоритма заключается в том, что он используется для хранения всех доступных наблюдений и классификации новых наблюдений большинством голосов своих k соседей. Затем случай присваивается классу, который является наиболее распространенным среди его K-ближайших соседей, измеренный функцией расстояния. Функция расстояния может быть евклидовым, расстоянием Минковского и расстоянием Хэмминга. Рассмотрим следующее, чтобы использовать KNN -

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

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

• В KNN нам нужно работать на этапе предварительной обработки, например, на удалении шума.

Кластеризация K-средних

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

• K-средство выбирает k точек для каждого кластера, известного как центроиды.

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

• Теперь он найдет центроиды каждого кластера на основе существующих членов кластера.

• Нам нужно повторять эти шаги, пока не произойдет схождение.

Случайный лес

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

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

• Они могут обрабатывать недостающие значения.

• Он не будет слишком соответствовать модели, даже если у нас будет больше деревьев в лесу.

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

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

Предварительная обработка данных

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

Этапы предварительной обработки данных

Выполните следующие шаги, чтобы предварительно обработать данные в Python -

Step 1 − Importing the useful packages - Если мы используем Python, это был бы первый шаг для преобразования данных в определенный формат, то есть предварительной обработки. Это можно сделать следующим образом -

import numpy as np
import sklearn.preprocessing

Здесь мы использовали следующие два пакета -

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

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

Step 2 − Defining sample data - После импорта пакетов нам нужно определить некоторые образцы данных, чтобы мы могли применить методы предварительной обработки к этим данным. Теперь мы определим следующие образцы данных -

input_data = np.array([2.1, -1.9, 5.5],
                      [-1.5, 2.4, 3.5],
                      [0.5, -7.9, 5.6],
                      [5.9, 2.3, -5.8])

Step3 − Applying preprocessing technique - На этом этапе нам нужно применить любой из методов предварительной обработки.

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

Методы предварительной обработки данных

Методы предварительной обработки данных описаны ниже -

Бинаризация

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

data_binarized = preprocessing.Binarizer(threshold = 0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)

Теперь, после выполнения приведенного выше кода, мы получим следующий вывод: все значения выше 0,5 (пороговое значение) будут преобразованы в 1, а все значения ниже 0,5 будут преобразованы в 0.

Binarized data

[[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]]

Среднее удаление

Это еще один очень распространенный метод предварительной обработки, который используется в машинном обучении. В основном он используется для исключения среднего из вектора признаков, чтобы каждый объект был центрирован на нуле. Мы также можем убрать смещение для признаков в векторе признаков. Чтобы применить метод предварительной обработки среднего удаления к образцам данных, мы можем написать код Python, показанный ниже. Код отобразит среднее и стандартное отклонение входных данных -

print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))

Мы получим следующий результат после выполнения приведенных выше строк кода -

Mean = [ 1.75       -1.275       2.2]
Std deviation = [ 2.71431391  4.20022321  4.69414529]

Теперь приведенный ниже код удалит среднее и стандартное отклонение входных данных -

data_scaled = preprocessing.scale(input_data)
print("Mean =", data_scaled.mean(axis=0))
print("Std deviation =", data_scaled.std(axis = 0))

Мы получим следующий результат после выполнения приведенных выше строк кода -

Mean = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Std deviation = [ 1.             1.             1.]

Масштабирование

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

# Min max scaling

data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)

Мы получим следующий результат после выполнения приведенных выше строк кода -

Min max scaled data

[ [ 0.48648649  0.58252427   0.99122807]
[   0.          1.           0.81578947]
[   0.27027027  0.           1.        ]
[   1.          0. 99029126  0.        ]]

Нормализация

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

L1 Normalization

Его также называют Least Absolute Deviations. Этот вид нормализации изменяет значения таким образом, чтобы сумма абсолютных значений всегда была до 1 в каждой строке. Его можно реализовать на входных данных с помощью следующего кода Python -

# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm = 'l1')
print("\nL1 normalized data:\n", data_normalized_l1)

Приведенная выше строка кода генерирует следующие выходные данные & miuns;

L1 normalized data:
[[ 0.22105263  -0.2          0.57894737]
[ -0.2027027    0.32432432   0.47297297]
[  0.03571429  -0.56428571   0.4       ]
[  0.42142857   0.16428571  -0.41428571]]

L2 Normalization

Его также называют least squares. Этот вид нормализации изменяет значения таким образом, чтобы сумма квадратов всегда была до 1 в каждой строке. Его можно реализовать на входных данных с помощью следующего кода Python -

# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm = 'l2')
print("\nL2 normalized data:\n", data_normalized_l2)

Приведенная выше строка кода сгенерирует следующий вывод -

L2 normalized data:
[[ 0.33946114  -0.30713151   0.88906489]
[ -0.33325106   0.53320169   0.7775858 ]
[  0.05156558  -0.81473612   0.57753446]
[  0.68706914   0.26784051  -0.6754239 ]]

Маркировка данных

Мы уже знаем, что данные в определенном формате необходимы для алгоритмов машинного обучения. Еще одно важное требование - данные должны быть правильно помечены перед отправкой их в качестве входных данных для алгоритмов машинного обучения. Например, если мы говорим о классификации, на данных много меток. Эти ярлыки имеют форму слов, чисел и т. Д. Функции, связанные с машинным обучением вsklearnожидайте, что данные должны иметь числовые метки. Следовательно, если данные представлены в другой форме, их необходимо преобразовать в числа. Этот процесс преобразования словарных меток в числовую форму называется кодированием меток.

Шаги кодирования этикеток

Выполните следующие шаги для кодирования меток данных в Python -

Step1 − Importing the useful packages

Если мы используем Python, то это будет первый шаг для преобразования данных в определенный формат, то есть предварительной обработки. Это можно сделать следующим образом -

import numpy as np
from sklearn import preprocessing

Step 2 − Defining sample labels

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

# Sample input labels
input_labels = ['red','black','red','green','black','yellow','white']

Step 3 − Creating & training of label encoder object

На этом этапе нам нужно создать кодировщик этикеток и обучить его. Следующий код Python поможет в этом -

# Creating the label encoder
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)

Ниже будет результат после запуска вышеуказанного кода Python -

LabelEncoder()

Step4 − Checking the performance by encoding random ordered list

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

# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)

Этикетки будут напечатаны следующим образом -

Labels = ['green', 'red', 'black']

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

print("Encoded values =", list(encoded_values))

Закодированные значения будут напечатаны следующим образом:

Encoded values = [1, 2, 0]

Step 5 − Checking the performance by decoding a random set of numbers −

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

# decoding a set of values
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
print("\nEncoded values =", encoded_values)

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

Encoded values = [3, 0, 4, 1]
print("\nDecoded labels =", list(decoded_list))

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

Decoded labels = ['white', 'black', 'yellow', 'green']

Помеченные и немаркированные данные

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

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

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

В этой главе мы сосредоточимся на реализации контролируемого обучения - классификации.

Методика классификации или модель пытается получить какой-то вывод из наблюдаемых значений. В задаче классификации у нас есть категоризованный вывод, такой как «Черный» или «белый» или «Обучение» и «Необучающее». При построении модели классификации нам нужен обучающий набор данных, содержащий точки данных и соответствующие метки. Например, если мы хотим проверить, является ли изображение автомобилем или нет. Чтобы проверить это, мы создадим обучающий набор данных, в котором два класса связаны с «автомобилем» и «без машины». Затем нам нужно обучить модель, используя обучающие образцы. Модели классификации в основном используются при распознавании лиц, идентификации спама и т. Д.

Шаги по созданию классификатора на Python

Для создания классификатора на Python мы собираемся использовать Python 3 и Scikit-learn, инструмент для машинного обучения. Выполните следующие шаги, чтобы создать классификатор в Python -

Шаг 1 - Импортируйте Scikit-learn

Это был бы самый первый шаг к созданию классификатора в Python. На этом этапе мы установим пакет Python под названием Scikit-learn, который является одним из лучших модулей машинного обучения в Python. Следующая команда поможет нам импортировать пакет -

Import Sklearn

Шаг 2 - Импортируйте набор данных Scikit-learn

На этом этапе мы можем начать работу с набором данных для нашей модели машинного обучения. Здесь мы будем использоватьthe Диагностическая база данных рака молочной железы Висконсина. Набор данных включает различную информацию об опухолях рака груди, а также классификационные меткиmalignant или же benign. Набор данных содержит 569 экземпляров или данных о 569 опухолях и включает информацию о 30 атрибутах или характеристиках, таких как радиус опухоли, текстура, гладкость и площадь. С помощью следующей команды мы можем импортировать набор данных рака молочной железы Scikit-learn -

from sklearn.datasets import load_breast_cancer

Теперь следующая команда загрузит набор данных.

data = load_breast_cancer()

Ниже приводится список важных словарных ключей -

• Имена классификационных ярлыков (target_names)
• Фактические метки (цель)
• Имена атрибутов / функций (имена объектов)
• Атрибут (данные)

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

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

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

print(label_names)

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

['malignant' 'benign']

Теперь команда ниже покажет, что они сопоставлены с двоичными значениями 0 и 1. Здесь 0 представляет злокачественный рак, а 1 представляет доброкачественный рак. Вы получите следующий вывод -

print(labels[0])
0

Две приведенные ниже команды произведут имена и значения функций.

print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Из вышеприведенного вывода мы видим, что первый экземпляр данных - это злокачественная опухоль, радиус которой составляет 1,7990000e + 01.

Шаг 3 - Организация данных в наборы

На этом этапе мы разделим наши данные на две части: обучающий набор и тестовый набор. Разделение данных на эти наборы очень важно, потому что мы должны протестировать нашу модель на невидимых данных. Для разделения данных на наборы в sklearn есть функция, называемаяtrain_test_split()функция. С помощью следующих команд мы можем разделить данные на эти наборы:

from sklearn.model_selection import train_test_split

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

train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)

Шаг 4 - Построение модели

На этом этапе мы будем строить нашу модель. Мы собираемся использовать алгоритм Наивного Байеса для построения модели. Следующие команды могут использоваться для построения модели -

from sklearn.naive_bayes import GaussianNB

Приведенная выше команда импортирует модуль GaussianNB. Теперь следующая команда поможет вам инициализировать модель.

gnb = GaussianNB()

Мы обучим модель, подгоняя ее к данным, используя gnb.fit ().

model = gnb.fit(train, train_labels)

Шаг 5 - Оценка модели и ее точности

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

preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 
 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0 
 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 
 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 
 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 
 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

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

Теперь, сравнивая два массива, а именно test_labels и preds, мы можем узнать точность нашей модели. Мы собираемся использоватьaccuracy_score()функция для определения точности. Рассмотрим для этого следующую команду -

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

Результат показывает, что классификатор NaïveBayes имеет точность 95,17%.

Таким образом, с помощью описанных выше шагов мы можем построить наш классификатор на Python.

Построение классификатора на Python

В этом разделе мы узнаем, как создать классификатор на Python.

Наивный байесовский классификатор

Наивный Байес - это метод классификации, используемый для построения классификатора с использованием теоремы Байеса. Предполагается, что предикторы независимы. Проще говоря, он предполагает, что наличие определенной функции в классе не связано с наличием какой-либо другой функции. Для создания наивного байесовского классификатора нам нужно использовать библиотеку Python под названием scikit learn. Существует три типа наивных байесовских моделей:Gaussian, Multinomial and Bernoulli в пакете scikit learn.

Чтобы построить наивную модель классификатора Байесовского машинного обучения, нам понадобится следующий & минус

Набор данных

Мы собираемся использовать набор данных под названием Breast Cancer Wisconsin Diagnostic Database. Набор данных включает различную информацию об опухолях рака груди, а также классификационные меткиmalignant или же benign. Набор данных содержит 569 экземпляров или данных о 569 опухолях и включает информацию о 30 атрибутах или характеристиках, таких как радиус опухоли, текстура, гладкость и площадь. Мы можем импортировать этот набор данных из пакета sklearn.

Наивная байесовская модель

Для построения наивного байесовского классификатора нам нужна наивная байесовская модель. Как говорилось ранее, существует три типа наивных байесовских моделей, названныхGaussian, Multinomial и Bernoulliв пакете scikit learn. Здесь в следующем примере мы собираемся использовать гауссовскую наивную байесовскую модель.

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

Для начала нам нужно установить модуль sklearn. Это можно сделать с помощью следующей команды -

Import Sklearn

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

from sklearn.datasets import load_breast_cancer

Теперь следующая команда загрузит набор данных.

data = load_breast_cancer()

Данные могут быть организованы следующим образом -

label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

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

print(label_names)

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

['malignant' 'benign']

Теперь команда, приведенная ниже, покажет, что они сопоставлены с двоичными значениями 0 и 1. Здесь 0 представляет злокачественный рак, а 1 представляет доброкачественный рак. Это показано как результат ниже -

print(labels[0])
0

Следующие две команды произведут имена и значения функций.

print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
  1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
  2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
  8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
  5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
  2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
  1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
  4.60100000e-01 1.18900000e-01]

Из вышеприведенного вывода мы видим, что первый экземпляр данных - это злокачественная опухоль, основной радиус которой составляет 1,7990000e + 01.

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

from sklearn.model_selection import train_test_split

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

train, test, train_labels, test_labels = 
train_test_split(features,labels,test_size = 0.40, random_state = 42)

Теперь мы строим модель с помощью следующих команд -

from sklearn.naive_bayes import GaussianNB

Приведенная выше команда импортирует GaussianNBмодуль. Теперь с помощью приведенной ниже команды нам нужно инициализировать модель.

gnb = GaussianNB()

Мы обучим модель, подогнав ее под данные, используя gnb.fit().

model = gnb.fit(train, train_labels)

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

preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0 
 0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0 
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0 
 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0 
 1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 
 1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0 
 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

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

Теперь, сравнивая два массива, а именно test_labels и preds, мы можем узнать точность нашей модели. Мы собираемся использоватьaccuracy_score()функция для определения точности. Рассмотрим следующую команду -

from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965

Результат показывает, что классификатор NaïveBayes имеет точность 95,17%.

Это был классификатор машинного обучения, основанный на модели Naïve Bayse Gaussian.

Машины опорных векторов (SVM)

По сути, машина опорных векторов (SVM) - это контролируемый алгоритм машинного обучения, который можно использовать как для регрессии, так и для классификации. Основная концепция SVM состоит в том, чтобы отобразить каждый элемент данных как точку в n-мерном пространстве, где значение каждой функции является значением конкретной координаты. Здесь n функций, которые у нас будут. Ниже приводится простое графическое представление, чтобы понять концепцию SVM.

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

Здесь мы собираемся создать классификатор SVM, используя scikit-learn и набор данных iris. Библиотека Scikitlearn имеетsklearn.svmмодуль и предоставляет sklearn.svm.svc для классификации. Классификатор SVM для прогнозирования класса ириса на основе 4 признаков показан ниже.

Набор данных

Мы будем использовать набор данных iris, который содержит 3 класса по 50 экземпляров каждый, где каждый класс относится к типу растения ириса. Каждый экземпляр имеет четыре характеристики, а именно длину чашелистика, ширину чашелистика, длину лепестка и ширину лепестка. Классификатор SVM для прогнозирования класса ириса на основе 4 признаков показан ниже.

Ядро

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

Давайте теперь импортируем следующие пакеты -

import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Теперь загрузите входные данные -

iris = datasets.load_iris()

Мы берем первые две функции -

X = iris.data[:, :2]
y = iris.target

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

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]

Нам нужно указать значение параметра регуляризации.

C = 1.0

Нам нужно создать объект классификатора SVM.

Svc_classifier = svm_classifier.SVC(kernel='linear', 
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')

Логистическая регрессия

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

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

В логистической регрессии оценка вероятностей означает прогнозирование вероятности наступления события. Например, владелец магазина хотел бы предсказать, что покупатель, вошедший в магазин, купит игровую приставку (например) или нет. У покупателя будет много характеристик - пол, возраст и т. Д., Которые будут наблюдаться владельцем магазина, чтобы предсказать вероятность возникновения, т. Е. Покупка игровой приставки или нет. Логистическая функция - это сигмовидная кривая, которая используется для построения функции с различными параметрами.

Предпосылки

Перед построением классификатора с использованием логистической регрессии нам необходимо установить пакет Tkinter в нашей системе. Его можно установить изhttps://docs.python.org/2/library/tkinter.html.

Теперь с помощью кода, приведенного ниже, мы можем создать классификатор с использованием логистической регрессии -

Сначала мы импортируем несколько пакетов -

import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt

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

X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6, 5], [7.6, 4],
              [3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4], [1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

Затем нам нужно создать классификатор логистической регрессии, что можно сделать следующим образом:

Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)

И последнее, но не менее важное: нам нужно обучить этот классификатор -

Classifier_LR.fit(X, y)

Теперь, как мы можем визуализировать результат? Это можно сделать, создав функцию с именем Logistic_visualize () -

Def Logistic_visualize(Classifier_LR, X, y):
   min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
   min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0

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

mesh_step_size = 0.02

Давайте определим сетку сетки значений X и Y следующим образом:

x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
                 np.arange(min_y, max_y, mesh_step_size))

С помощью следующего кода мы можем запустить классификатор в сетке сетки -

output = classifier.predict(np.c_[x_vals.ravel(), y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)
 
plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors = 'black', 
linewidth=1, cmap = plt.cm.Paired)

В следующей строке кода будут указаны границы графика.

plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:, 0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:, 1].max() + 1), 1.0)))
plt.show()

Теперь, после запуска кода, мы получим следующий вывод, классификатор логистической регрессии -

Классификатор дерева решений

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

Здесь мы создаем классификатор дерева решений для прогнозирования мужского или женского пола. Мы возьмем очень небольшой набор данных из 19 образцов. Эти образцы будут состоять из двух характеристик - «рост» и «длина волос».

Предпосылка

Для построения следующего классификатора нам необходимо установить pydotplus и graphviz. По сути, graphviz - это инструмент для рисования графики с использованием точечных файлов иpydotplusявляется модулем языка точек Graphviz. Его можно установить с помощью диспетчера пакетов или pip.

Теперь мы можем построить классификатор дерева решений с помощью следующего кода Python:

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

import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections

Теперь нам нужно предоставить набор данных следующим образом:

X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y = ['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)

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

clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

Прогнозирование можно сделать с помощью следующего кода Python -

prediction = clf.predict([[133,37]])
print(prediction)

Мы можем визуализировать дерево решений с помощью следующего кода Python -

dot_data = tree.export_graphviz(clf,feature_names = data_feature_names,
            out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():
edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest = graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')

Это даст прогноз для приведенного выше кода как [‘Woman’] и создайте следующее дерево решений -

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

Классификатор случайного леса

Как мы знаем, ансамблевые методы - это методы, которые объединяют модели машинного обучения в более мощную модель машинного обучения. Случайный лес, набор деревьев решений, является одним из них. Это лучше, чем одиночное дерево решений, потому что, сохраняя возможности прогнозирования, оно может уменьшить чрезмерную подгонку за счет усреднения результатов. Здесь мы собираемся реализовать модель случайного леса в наборе данных scikit learn Cancer.

Импортируйте необходимые пакеты -

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np

Теперь нам нужно предоставить набор данных, что можно сделать следующим образом & минус

cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)

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

forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)

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

print('Accuracy on the training subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training subset:(:.3f)',format(forest.score(X_test,y_test)))

Вывод

Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965

Теперь, как и дерево решений, случайный лес имеет feature_importanceмодуль, который обеспечит лучшее представление о весе функции, чем дерево решений. Его можно построить и визуализировать следующим образом:

n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_, align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()

Производительность классификатора

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

Матрица путаницы

В основном он используется для задач классификации, где на выходе могут быть два или более типов классов. Это самый простой способ измерить эффективность классификатора. Матрица неточностей - это в основном таблица с двумя измерениями, а именно «Фактическая» и «Прогнозируемая». Оба измерения имеют «Истинные положительные результаты (TP)», «Истинные отрицательные результаты (TN)», «Ложные положительные результаты (FP)», «Ложные отрицательные результаты (FN)».

В приведенной выше матрице путаницы 1 соответствует положительному классу, а 0 - отрицательному классу.

Ниже приведены термины, связанные с матрицей путаницы.

• True Positives − TP - это случаи, когда фактический класс точки данных был 1, а прогнозируемый также 1.

• True Negatives − TN - это случаи, когда фактический класс точки данных был равен 0, а прогнозируемый также равен 0.

• False Positives − FP - это случаи, когда фактический класс точки данных был равен 0, а прогнозируемый также равен 1.

• False Negatives − FN - это случаи, когда фактический класс точки данных был 1, а прогнозируемый также 0.

Точность

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

$$ Точность = \ frac {TP + TN} {TP + FP + FN + TN} $$

Точность

Он в основном используется при поиске документов. Это может быть определено как количество верных документов. Ниже приведена формула для расчета точности -

$$ Точность = \ frac {TP} {TP + FP} $$

Отзыв или чувствительность

Его можно определить как количество положительных результатов, которые дает модель. Ниже приведена формула для расчета отзывчивости / чувствительности модели.

$$ Recall = \ frac {TP} {TP + FN} $$

Специфика

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

$$ Специфика = \ frac {TN} {TN + FP} $$

Проблема дисбаланса классов

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

Пример несбалансированных классов

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

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Решение

Balancing the classes’действует как решение несбалансированных классов. Основная цель уравновешивания классов состоит в том, чтобы либо увеличить частоту класса меньшинства, либо уменьшить частоту класса большинства. Ниже приведены подходы к решению проблемы классов дисбаланса.

Повторная выборка

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

• Random Under-Sampling- Этот метод направлен на сбалансированное распределение классов путем случайного исключения примеров большинства классов. Это делается до тех пор, пока экземпляры классов большинства и меньшинства не будут сбалансированы.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

В этом случае мы берем 10% образцов без замены из случаев, не связанных с мошенничеством, а затем объединяем их с экземплярами мошенничества -

Не мошеннические наблюдения после случайной недостаточной выборки = 10% от 4950 = 495

Общее количество наблюдений после их объединения с мошенническими наблюдениями = 50 + 495 = 545

Следовательно, теперь частота событий для нового набора данных после недостаточной выборки = 9%.

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

• Random Over-Sampling - Этот метод направлен на сбалансированное распределение классов за счет увеличения количества экземпляров в классе меньшинства путем их репликации.

Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

В случае, если мы реплицируем 50 мошеннических наблюдений 30 раз, то мошеннические наблюдения после репликации наблюдений класса меньшинств будут 1500. И тогда общее количество наблюдений в новых данных после передискретизации будет 4950 + 1500 = 6450. Следовательно, частота событий для нового набора данных будет 1500/6450 = 23%.

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

Ансамблевые техники

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

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

Построение регрессоров в Python

В этом разделе мы узнаем, как построить регрессор как с одним, так и с несколькими переменными.

Линейный регрессор / Регрессор с одной переменной

Давайте отметим несколько необходимых пакетов -

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt

Теперь нам нужно предоставить входные данные, и мы сохранили наши данные в файле с именем linear.txt.

input = 'D:/ProgramData/linear.txt'

Нам нужно загрузить эти данные с помощью np.loadtxt функция.

input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]

Следующим шагом будет обучение модели. Приведем обучающие и тестовые образцы.

training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Теперь нам нужно создать объект линейного регрессора.

reg_linear = linear_model.LinearRegression()

Обучите объект на обучающих образцах.

reg_linear.fit(X_train, y_train)

Нам нужно сделать прогноз на основе данных тестирования.

y_test_pred = reg_linear.predict(X_test)

Теперь постройте и визуализируйте данные.

plt.scatter(X_test, y_test, color = 'red')
plt.plot(X_test, y_test_pred, color = 'black', linewidth = 2)
plt.xticks(())
plt.yticks(())
plt.show()

Вывод

Теперь мы можем вычислить производительность нашей линейной регрессии следующим образом:

print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred),
2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))

Вывод

Производительность линейного регрессора -

Mean absolute error = 1.78
Mean squared error = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09

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

2,4.82.9,4.72.5,53.2,5.56,57.6,43.2,0.92.9,1.92.4,
3.50.5,3.41,40.9,5.91.2,2.583.2,5.65.1,1.54.5,
1.22.3,6.32.1,2.8

Многовариантный регрессор

Во-первых, давайте импортируем несколько необходимых пакетов -

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures

Теперь нам нужно предоставить входные данные, и мы сохранили наши данные в файле с именем linear.txt.

input = 'D:/ProgramData/Mul_linear.txt'

Мы загрузим эти данные с помощью np.loadtxt функция.

input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]

Следующим шагом будет обучение модели; предоставим обучающие и тестовые образцы.

training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Теперь нам нужно создать объект линейного регрессора.

reg_linear_mul = linear_model.LinearRegression()

Обучите объект на обучающих образцах.

reg_linear_mul.fit(X_train, y_train)

Теперь, наконец, нам нужно сделать прогноз на основе данных тестирования.

y_test_pred = reg_linear_mul.predict(X_test)

print("Performance of Linear regressor:")
print("Mean absolute error =", round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =", round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =", round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =", round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred), 2))

Вывод

Производительность линейного регрессора -

Mean absolute error = 0.6
Mean squared error = 0.65
Median absolute error = 0.41
Explain variance score = 0.34
R2 score = 0.33

Теперь мы создадим многочлен 10-й степени и обучим регрессор. Мы предоставим образец данных.

polynomial = PolynomialFeatures(degree = 10)
X_train_transformed = polynomial.fit_transform(X_train)
datapoint = [[2.23, 1.35, 1.12]]
poly_datapoint = polynomial.fit_transform(datapoint)

poly_linear_model = linear_model.LinearRegression()
poly_linear_model.fit(X_train_transformed, y_train)
print("\nLinear regression:\n", reg_linear_mul.predict(datapoint))
print("\nPolynomial regression:\n", poly_linear_model.predict(poly_datapoint))

Вывод

Линейная регрессия -

[2.40170462]

Полиномиальная регрессия -

[1.8697225]

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

2,4.8,1.2,3.22.9,4.7,1.5,3.62.5,5,2.8,23.2,5.5,3.5,2.16,5,
2,3.27.6,4,1.2,3.23.2,0.9,2.3,1.42.9,1.9,2.3,1.22.4,3.5,
2.8,3.60.5,3.4,1.8,2.91,4,3,2.50.9,5.9,5.6,0.81.2,2.58,
3.45,1.233.2,5.6,2,3.25.1,1.5,1.2,1.34.5,1.2,4.1,2.32.3,
6.3,2.5,3.22.1,2.8,1.2,3.6

В этой главе мы сосредоточимся на логическом программировании и на том, как оно помогает в искусственном интеллекте.

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

Концепция

Логическое программирование - это сочетание двух слов: логики и программирования. Логическое программирование - это парадигма программирования, в которой проблемы выражаются в виде фактов и правил с помощью программных операторов, но в рамках системы формальной логики. Как и другие парадигмы программирования, такие как объектно-ориентированное, функциональное, декларативное, процедурное и т. Д., Это также особый подход к программированию.

Как решать проблемы с логическим программированием

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

Факты

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

Правила

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

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

A∶− B1, B2, ..., B _n .

Здесь A - голова, а B1, B2, ... Bn - тело.

Например - предок (X, Y): - отец (X, Y).

предок (X, Z): - отец (X, Y), предок (Y, Z).

Это можно читать так: для любых X и Y, если X является отцом Y, а Y является предком Z, X является предком Z. Для любых X и Y X является предком Z, если X является отец Y и Y является предком Z.

Установка полезных пакетов

Чтобы начать логическое программирование на Python, нам нужно установить следующие два пакета:

Канрен

Это дает нам возможность упростить создание кода для бизнес-логики. Это позволяет нам выразить логику в терминах правил и фактов. Следующая команда поможет вам установить канрен -

pip install kanren

SymPy

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

pip install sympy

Примеры логического программирования

Ниже приведены некоторые примеры, которые можно решить с помощью логического программирования.

Соответствие математических выражений

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

Сначала рассмотрите возможность импорта следующих пакетов -

from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative

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

add = 'add'
mul = 'mul'

И сложение, и умножение - коммуникативные процессы. Следовательно, нам нужно указать его, и это можно сделать следующим образом:

fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)

Определение переменных обязательно; это можно сделать следующим образом -

a, b = var('a'), var('b')

Нам нужно сопоставить выражение с исходным шаблоном. У нас есть следующий исходный шаблон, который по сути (5 + a) * b -

Original_pattern = (mul, (add, 5, a), b)

У нас есть следующие два выражения, чтобы соответствовать исходному шаблону -

exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))

Вывод можно распечатать с помощью следующей команды -

print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))

После запуска этого кода мы получим следующий вывод -

((3,2))
()

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

Проверка простых чисел

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

Давайте сначала рассмотрим импорт следующих пакетов -

from kanren import isvar, run, membero
from kanren.core import success, fail, goaleval, condeseq, eq, var
from sympy.ntheory.generate import prime, isprime
import itertools as it

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

def prime_check(x):
if isvar(x):
   return condeseq([(eq,x,p)] for p in map(prime, it.count(1)))
else:
   return success if isprime(x) else fail

Теперь нам нужно объявить переменную, которая будет использоваться -

x = var()
print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,41,44,52,62,65,85)),
(prime_check,x)))))
print((run(10,x,prime_check(x))))

Вывод приведенного выше кода будет следующим:

{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

Решение головоломок

Логическое программирование можно использовать для решения многих задач, таких как 8-головоломки, головоломка с зеброй, судоку, N-королева и т. Д. Здесь мы берем пример варианта головоломки с зеброй, который выглядит следующим образом:

There are five houses.
The English man lives in the red house.
The Swede has a dog.
The Dane drinks tea.
The green house is immediately to the left of the white house.
They drink coffee in the green house.
The man who smokes Pall Mall has birds.
In the yellow house they smoke Dunhill.
In the middle house they drink milk.
The Norwegian lives in the first house.
The man who smokes Blend lives in the house next to the house with cats.
In a house next to the house where they have a horse, they smoke Dunhill.
The man who smokes Blue Master drinks beer.
The German smokes Prince.
The Norwegian lives next to the blue house.
They drink water in a house next to the house where they smoke Blend.

Решаем для вопроса who owns zebra с помощью Python.

Импортируем необходимые пакеты -

from kanren import *
from kanren.core import lall
import time

Теперь нам нужно определить две функции - left() и next() проверить, чей дом остался или рядом чей дом -

def left(q, p, list):
   return membero((q,p), zip(list, list[1:]))
def next(q, p, list):
   return conde([left(q, p, list)], [left(p, q, list)])

Теперь мы объявим переменный дом следующим образом:

houses = var()

Нам нужно определить правила с помощью пакета lall следующим образом.

Всего 5 домов -

rules_zebraproblem = lall(
   (eq, (var(), var(), var(), var(), var()), houses),

   (membero,('Englishman', var(), var(), var(), 'red'), houses),
   (membero,('Swede', var(), var(), 'dog', var()), houses),
   (membero,('Dane', var(), 'tea', var(), var()), houses),
   (left,(var(), var(), var(), var(), 'green'),
   (var(), var(), var(), var(), 'white'), houses),
   (membero,(var(), var(), 'coffee', var(), 'green'), houses),
   (membero,(var(), 'Pall Mall', var(), 'birds', var()), houses),
   (membero,(var(), 'Dunhill', var(), var(), 'yellow'), houses),
   (eq,(var(), var(), (var(), var(), 'milk', var(), var()), var(), var()), houses),
   (eq,(('Norwegian', var(), var(), var(), var()), var(), var(), var(), var()), houses),
   (next,(var(), 'Blend', var(), var(), var()),
   (var(), var(), var(), 'cats', var()), houses),
   (next,(var(), 'Dunhill', var(), var(), var()),
   (var(), var(), var(), 'horse', var()), houses),
   (membero,(var(), 'Blue Master', 'beer', var(), var()), houses),
   (membero,('German', 'Prince', var(), var(), var()), houses),
   (next,('Norwegian', var(), var(), var(), var()),
   (var(), var(), var(), var(), 'blue'), houses),
   (next,(var(), 'Blend', var(), var(), var()),
   (var(), var(), 'water', var(), var()), houses),
   (membero,(var(), var(), var(), 'zebra', var()), houses)
)

Теперь запустите решатель с предыдущими ограничениями -

solutions = run(0, houses, rules_zebraproblem)

С помощью следующего кода мы можем извлечь результат работы решателя:

output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]

Следующий код поможет распечатать решение -

print ('\n'+ output_zebra + 'owns zebra.')

Вывод приведенного выше кода будет следующим:

German owns zebra.

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

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

Что такое кластеризация?

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

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

Алгоритмы кластеризации данных

Ниже приведены несколько общих алгоритмов кластеризации данных.

Алгоритм K-средних

Алгоритм кластеризации K-средних является одним из хорошо известных алгоритмов кластеризации данных. Нам нужно предположить, что количество кластеров уже известно. Это также называется плоской кластеризацией. Это итеративный алгоритм кластеризации. Для этого алгоритма необходимо выполнить шаги, указанные ниже -

Step 1 - Нам нужно указать желаемое количество K подгрупп.

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

На этом этапе следует вычислить центроиды кластера.

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

Следующий код поможет в реализации алгоритма кластеризации K-средних в Python. Мы собираемся использовать модуль Scikit-learn.

Импортируем необходимые пакеты -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Следующая строка кода поможет создать двумерный набор данных, содержащий четыре больших двоичных объекта, с помощью make_blob из sklearn.dataset пакет.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,
            cluster_std = 0.40, random_state = 0)

Мы можем визуализировать набор данных, используя следующий код -

plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()

Здесь мы инициализируем kmeans как алгоритм KMeans с обязательным параметром количества кластеров (n_clusters).

kmeans = KMeans(n_clusters = 4)

Нам нужно обучить модель K-средних с входными данными.

kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')

centers = kmeans.cluster_centers_

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

plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()

Алгоритм среднего сдвига

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

• Прежде всего, нам нужно начать с точек данных, назначенных собственному кластеру.

• Теперь он вычисляет центроиды и обновляет местоположение новых центроидов.

• Повторяя этот процесс, мы приближаемся к пику кластера, то есть к области более высокой плотности.

• Этот алгоритм останавливается на этапе, когда центроиды больше не перемещаются.

С помощью следующего кода мы реализуем алгоритм кластеризации среднего сдвига в Python. Мы собираемся использовать модуль Scikit-learn.

Импортируем необходимые пакеты -

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

Следующий код поможет создать двумерный набор данных, содержащий четыре больших двоичных объекта, с помощью make_blob из sklearn.dataset пакет.

from sklearn.datasets.samples_generator import make_blobs

Мы можем визуализировать набор данных с помощью следующего кода

centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

Теперь нам нужно обучить кластерную модель среднего сдвига с входными данными.

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

Следующий код напечатает центры кластеров и ожидаемое количество кластеров в соответствии с входными данными -

print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

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

colors = 10*['r.','g.','b.','c.','k.','y.','m.']
   for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
   marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()

Измерение эффективности кластеризации

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

Анализ силуэта

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

Анализ силуэта

Оценка имеет диапазон [-1, 1]. Ниже приводится анализ этой оценки -

• Score of +1 - Оценка около +1 указывает на то, что образец находится далеко от соседнего кластера.

• Score of 0 - Оценка 0 указывает, что выборка находится на границе принятия решения между двумя соседними кластерами или очень близко к ней.

• Score of -1 - Отрицательный результат указывает на то, что образцы были отнесены к неправильным кластерам.

Расчет показателя силуэта

В этом разделе мы узнаем, как рассчитать оценку силуэта.

Оценка силуэта может быть рассчитана по следующей формуле -

$$ силуэт оценка = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$

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

Чтобы найти оптимальное количество кластеров, нам нужно снова запустить алгоритм кластеризации, импортировав metrics модуль из sklearnпакет. В следующем примере мы запустим алгоритм кластеризации K-средних, чтобы найти оптимальное количество кластеров:

Импортируйте необходимые пакеты, как показано -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

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

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)

Инициализируйте переменные, как показано -

scores = []
values = np.arange(2, 10)

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

for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)

Теперь оцените оценку силуэта для текущей модели кластеризации, используя метрику евклидова расстояния -

score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))

Следующая строка кода поможет отобразить количество кластеров, а также оценку Silhouette.

print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)

Вы получите следующий вывод -

Number of clusters = 9
Silhouette score = 0.340391138371

num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)

Теперь результат для оптимального количества кластеров будет следующим:

Optimal number of clusters = 2

Поиск ближайших соседей

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

В concept of finding nearest neighborsможно определить как процесс поиска ближайшей точки к входной точке из данного набора данных. Основное использование этого алгоритма KNN) K-ближайших соседей) состоит в создании систем классификации, которые классифицируют точку данных по близости точки входных данных к различным классам.

Приведенный ниже код Python помогает найти K-ближайших соседей данного набора данных -

Импортируйте необходимые пакеты, как показано ниже. Здесь мы используемNearestNeighbors модуль из sklearn пакет

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors

Давайте теперь определим входные данные -

A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9], 
             [8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])

Теперь нам нужно определить ближайших соседей -

k = 3

Нам также нужно предоставить тестовые данные, по которым должны быть найдены ближайшие соседи -

test_data = [3.3, 2.9]

Следующий код может визуализировать и отображать определенные нами входные данные:

plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')

Теперь нам нужно построить K ближайшего соседа. Объект тоже нужно обучить

knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])

Теперь мы можем вывести K ближайших соседей следующим образом

print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
   print(str(rank) + " is", A[index])

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

plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
   marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
   marker = 'x', s = 100, color = 'k')
plt.show()

Вывод

K Nearest Neighbors

1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]

Классификатор K-ближайших соседей

Классификатор K-ближайших соседей (KNN) - это модель классификации, которая использует алгоритм ближайших соседей для классификации заданной точки данных. В предыдущем разделе мы реализовали алгоритм KNN, теперь мы собираемся построить классификатор KNN, используя этот алгоритм.

Понятие классификатора KNN

Основная концепция классификации K-ближайших соседей состоит в том, чтобы найти предопределенное число, т. Е. «K» - обучающих выборок, ближайших по расстоянию к новой выборке, которую необходимо классифицировать. Новые образцы получат этикетку от самих соседей. Классификаторы KNN имеют фиксированную константу, определяемую пользователем, для количества соседей, которые должны быть определены. Для расстояния наиболее распространенным выбором является стандартное евклидово расстояние. Классификатор KNN работает непосредственно с изученными образцами, а не создает правила для обучения. Алгоритм KNN - один из самых простых алгоритмов машинного обучения. Он оказался весьма успешным в большом количестве задач классификации и регрессии, например, при распознавании символов или анализе изображений.

Example

Мы создаем классификатор KNN для распознавания цифр. Для этого мы будем использовать набор данных MNIST. Мы напишем этот код в Jupyter Notebook.

Импортируйте необходимые пакеты, как показано ниже.

Здесь мы используем KNeighborsClassifier модуль из sklearn.neighbors пакет -

from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np

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

def Image_display(i):
   plt.imshow(digit['images'][i],cmap = 'Greys_r')
   plt.show()

Теперь нам нужно загрузить набор данных MNIST. На самом деле всего 1797 изображений, но мы используем первые 1600 изображений в качестве обучающей выборки, а оставшиеся 197 оставим для тестирования.

digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])

Теперь при отображении изображений мы можем увидеть результат следующим образом:

Image_display(0)

Image_display (0)

Изображение 0 отображается следующим образом -

Image_display (9)

Изображение 9 отображается следующим образом -

digit.keys ()

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

train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)

Следующий вывод создаст конструктор классификатора ближайшего соседа K -

KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
   weights = 'uniform')

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

test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)

Image_display (6)

Изображение 6 отображается следующим образом -

Теперь мы будем прогнозировать тестовые данные следующим образом -

KNN.predict(test1)

Приведенный выше код сгенерирует следующий вывод -

array([6])

Теперь рассмотрим следующее -

digit['target_names']

Приведенный выше код сгенерирует следующий вывод -

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Обработка естественного языка (NLP) относится к методу ИИ для связи с интеллектуальными системами с использованием естественного языка, такого как английский.

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

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

• Speech
• Письменный текст

Компоненты НЛП

В этом разделе мы узнаем о различных компонентах НЛП. НЛП состоит из двух компонентов. Компоненты описаны ниже -

Понимание естественного языка (NLU)

Он включает в себя следующие задачи -

• Отображение заданного ввода на естественном языке в полезные представления.

• Анализируем разные аспекты языка.

Генерация естественного языка (NLG)

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

• Text planning - Сюда входит получение соответствующего контента из базы знаний.

• Sentence planning - Сюда входит выбор необходимых слов, формирование значащих фраз, установка тона предложения.

• Text Realization - Это отображение плана предложения в структуру предложения.

Трудности в НЛУ

НЛУ очень богат по форме и структуре; однако это неоднозначно. Могут быть разные уровни двусмысленности -

Лексическая двусмысленность

Он находится на очень примитивном уровне, таком как уровень слов. Например, рассматривать слово «доска» как существительное или глагол?

Неопределенность на уровне синтаксиса

Предложение можно разобрать по-разному. Например: «Жук с красной шапкой поднял». - Поднимал ли он жука колпаком или он поднимал жука с красной шляпкой?

Ссылочная двусмысленность

Обращение к чему-либо с использованием местоимений. Например, Римма пошла к Гаури. Она сказала: «Я устала». - Кто именно устал?

Терминология НЛП

Давайте теперь посмотрим на несколько важных терминов в терминологии НЛП.

• Phonology - Это систематическое изучение организации звука.

• Morphology - Это исследование построения слов из примитивных значимых единиц.

• Morpheme - Это примитивная единица значения в языке.

• Syntax- Это относится к составлению предложения из слов. Это также включает определение структурной роли слов в предложении и во фразах.

• Semantics - Это касается значения слов и того, как объединять слова в значимые фразы и предложения.

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

• Discourse - Это касается того, как предыдущее предложение может повлиять на интерпретацию следующего предложения.

• World Knowledge - Включает в себя общие знания о мире.

Шаги в НЛП

В этом разделе показаны различные этапы НЛП.

Лексический анализ

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

Синтаксический анализ (парсинг)

Он включает в себя анализ слов в предложении на предмет грамматики и расположение слов таким образом, чтобы показать взаимосвязь между словами. Такое предложение, как «Школа идет мальчику», отклоняется синтаксическим анализатором английского языка.

Семантический анализ

Он извлекает точное значение или словарное значение из текста. Текст проверяется на осмысленность. Это делается путем сопоставления синтаксических структур и объектов в области задач. Семантический анализатор игнорирует такие предложения, как «горячее мороженое».

Интеграция дискурса

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

Прагматический анализ

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

В этой главе мы узнаем, как начать работу с пакетом Natural Language Toolkit.

Предпосылка

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

Для создания таких приложений мы будем использовать пакет Python под названием NLTK (Natural Language Toolkit Package).

Импорт NLTK

Нам необходимо установить NLTK перед его использованием. Его можно установить с помощью следующей команды -

pip install nltk

Чтобы создать пакет conda для NLTK, используйте следующую команду -

conda install -c anaconda nltk

Теперь, после установки пакета NLTK, нам нужно импортировать его через командную строку python. Мы можем импортировать его, написав следующую команду в командной строке Python -

>>> import nltk

Скачивание данных НЛТК

Теперь после импорта NLTK нам нужно скачать необходимые данные. Это можно сделать с помощью следующей команды в командной строке Python -

>>> nltk.download()

Установка других необходимых пакетов

Для создания приложений обработки естественного языка с использованием NLTK нам необходимо установить необходимые пакеты. Пакеты следующие -

Gensim

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

pip install gensim

шаблон

Он используется для изготовления gensimпакет работает правильно. Мы можем установить его, выполнив следующую команду

pip install pattern

Концепция токенизации, стемминга и лемматизации

В этом разделе мы поймем, что такое токенизация, стемминг и лемматизация.

Токенизация

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

Input - Манго, банан, ананас и яблоко - все это фрукты.

Output -

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

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

sent_tokenize пакет

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

from nltk.tokenize import sent_tokenize

word_tokenize пакет

Этот пакет делит вводимый текст на слова. Мы можем импортировать этот пакет с помощью следующего кода Python -

from nltk.tokenize import word_tokenize

Пакет WordPunctTokenizer

Этот пакет разделяет вводимый текст на слова и знаки препинания. Мы можем импортировать этот пакет с помощью следующего кода Python -

from nltk.tokenize import WordPuncttokenizer

Стемминг

При работе со словами мы сталкиваемся с множеством вариаций по грамматическим причинам. Концепция вариаций здесь означает, что мы имеем дело с разными формами одних и тех же слов, напримерdemocracy, democratic, и democratization. Машинам очень важно понимать, что эти разные слова имеют одинаковую базовую форму. Таким образом, было бы полезно извлечь базовые формы слов, пока мы анализируем текст.

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

В модуле Python NLTK у нас есть разные пакеты, связанные со стеммингом. Эти пакеты можно использовать для получения базовых форм слова. Эти пакеты используют алгоритмы. Некоторые из пакетов следующие -

Пакет PorterStemmer

Этот пакет Python использует алгоритм Портера для извлечения базовой формы. Мы можем импортировать этот пакет с помощью следующего кода Python -

from nltk.stem.porter import PorterStemmer

Например, если мы дадим слово ‘writing’ в качестве входных данных для этого стеммера мы получим слово ‘write’ после забоя.

Пакет LancasterStemmer

Этот пакет Python будет использовать алгоритм Ланкастера для извлечения базовой формы. Мы можем импортировать этот пакет с помощью следующего кода Python -

from nltk.stem.lancaster import LancasterStemmer

Например, если мы дадим слово ‘writing’ в качестве входных данных для этого стеммера мы получим слово ‘write’ после забоя.

Пакет SnowballStemmer

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

from nltk.stem.snowball import SnowballStemmer

Например, если мы дадим слово ‘writing’ в качестве входных данных для этого стеммера мы получим слово ‘write’ после забоя.

Все эти алгоритмы имеют разную степень строгости. Если мы сравним эти три стеммера, то стеммер Портера наименее строгий, а Ланкастер самый строгий. Стеммер Snowball хорош как с точки зрения скорости, так и с точки зрения строгости.

Лемматизация

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

Основное различие между стеммингом и лемматизацией - это использование словарного запаса и морфологический анализ слов. Еще одно отличие состоит в том, что основание чаще всего сворачивает словообразовательно связанные слова, тогда как лемматизация обычно сворачивает только различные словоизменительные формы леммы. Например, если мы предоставим слово saw в качестве входного слова, то основание может вернуть слово s, но лемматизация будет пытаться вернуть слово see или saw в зависимости от того, использовался ли токен глаголом или существительным.

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

Пакет WordNetLemmatizer

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

from nltk.stem import WordNetLemmatizer

Разделение на части: разделение данных на фрагменты

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

В следующем разделе мы узнаем о различных типах разбиения на части.

Типы фрагментов

Есть два типа фрагментов. Типы следующие -

Разбивать

В этом процессе фрагментов объект, вещи и т. Д. Становятся более общими, а язык становится более абстрактным. Шансов на согласие больше. В этом процессе мы уменьшаем масштаб. Например, если мы разберемся с вопросом, «для чего нужны автомобили»? Мы можем получить ответ «транспорт».

Дробление

В этом процессе разбиения на части объект, вещи и т. Д. Становятся более конкретными, и язык становится более проникнутым. Более глубокая структура будет исследована при разделении на части. В этом процессе мы увеличиваем масштаб. Например, если мы разберем вопрос «Расскажите конкретно об автомобиле»? Мы получим более мелкие сведения об автомобиле.

Example

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

Follow these steps in python for implementing noun phrase chunking −

Step 1- На этом этапе нам нужно определить грамматику для разбиения на части. Он будет состоять из правил, которым мы должны следовать.

Step 2- На этом этапе нам нужно создать парсер чанков. Он проанализирует грамматику и выдаст результат.

Step 3 - На этом последнем шаге вывод создается в формате дерева.

Давайте импортируем необходимый пакет NLTK следующим образом -

import nltk

Теперь нам нужно определить предложение. Здесь DT означает определитель, VBP означает глагол, JJ означает прилагательное, IN означает предлог, а NN означает существительное.

sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP"),
          ("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]

Теперь нам нужно дать грамматику. Здесь мы дадим грамматику в виде регулярного выражения.

grammar = "NP:{<DT>?<JJ>*<NN>}"

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

parser_chunking = nltk.RegexpParser(grammar)

Парсер разбирает предложение следующим образом -

parser_chunking.parse(sentence)

Далее нам нужно получить результат. Вывод генерируется в простой переменной с именемoutput_chunk.

Output_chunk = parser_chunking.parse(sentence)

После выполнения следующего кода мы можем нарисовать наш вывод в виде дерева.

output.draw()

Модель мешка слов (BoW)

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

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

Как это устроено

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

Понятие матрицы терминов документа

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

Example

Предположим, у нас есть следующие два предложения -

• Sentence 1 - Мы используем модель «Мешок слов».

• Sentence 2 - Модель Bag of Words используется для извлечения функций.

Теперь, рассматривая эти два предложения, мы получаем следующие 13 различных слов:

• we
• are
• using
• the
• bag
• of
• words
• model
• is
• used
• for
• extracting
• features

Теперь нам нужно построить гистограмму для каждого предложения, используя количество слов в каждом предложении -

• Sentence 1 - [1,1,1,1,1,1,1,1,0,0,0,0,0]

• Sentence 2 - [0,0,0,1,1,1,1,1,1,1,1,1,1]

Таким образом, у нас есть извлеченные векторы признаков. Каждый вектор признаков 13-мерный, потому что у нас есть 13 различных слов.

Понятие статистики

Концепция статистики называется TermFrequency-Inverse Document Frequency (tf-idf). В документе важно каждое слово. Статистика помогает нам понять важность каждого слова.

Срок действия (тс)

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

Частота обратного документа (idf)

Это мера того, насколько уникально слово для данного документа в данном наборе документов. Для вычисления idf и формулирования вектора отличительных признаков нам необходимо уменьшить веса часто встречающихся слов, таких как the, и взвесить редкие слова.

Построение модели мешка слов в NLTK

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

Импортируем необходимый пакет -

from sklearn.feature_extraction.text import CountVectorizer

Теперь определите набор предложений.

Sentences = ['We are using the Bag of Word model', 'Bag of Word model is
           used for extracting the features.']

vectorizer_count = CountVectorizer()

features_text = vectorizer.fit_transform(Sentences).todense()

print(vectorizer.vocabulary_)

Вышеупомянутая программа генерирует выходные данные, как показано ниже. Это показывает, что у нас есть 13 различных слов в двух приведенных выше предложениях -

{'we': 11, 'are': 0, 'using': 10, 'the': 8, 'bag': 1, 'of': 7,
 'word': 12, 'model': 6, 'is': 5, 'used': 9, 'for': 4, 'extracting': 2, 'features': 3}

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

Решение проблем

В этом разделе мы решим несколько связанных проблем.

Категория Прогноз

В комплекте документов важны не только слова, но и категория слов; к какой категории текста относится конкретное слово. Например, мы хотим предсказать, принадлежит ли данное предложение категории электронная почта, новости, спорт, компьютер и т. Д. В следующем примере мы собираемся использовать tf-idf, чтобы сформулировать вектор признаков для поиска категории документов. Мы будем использовать данные из набора данных 20 групп новостей sklearn.

Нам нужно импортировать необходимые пакеты -

from sklearn.datasets import fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer

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

category_map = {'talk.religion.misc':'Religion','rec.autos''Autos',
   'rec.sport.hockey':'Hockey','sci.electronics':'Electronics', 'sci.space': 'Space'}

Создайте обучающий набор -

training_data = fetch_20newsgroups(subset = 'train',
   categories = category_map.keys(), shuffle = True, random_state = 5)

Создайте векторизатор подсчета и извлеките количество терминов -

vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)

Трансформатор tf-idf создается следующим образом -

tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)

Теперь определите тестовые данные -

input_data = [
   'Discovery was a space shuttle',
   'Hindu, Christian, Sikh all are religions',
   'We must have to drive safely',
   'Puck is a disk made of rubber',
   'Television, Microwave, Refrigrated all uses electricity'
]

Приведенные выше данные помогут нам обучить полиномиальный наивный байесовский классификатор -

classifier = MultinomialNB().fit(train_tfidf, training_data.target)

Преобразуйте входные данные с помощью векторизатора счета -

input_tc = vectorizer_count.transform(input_data)

Теперь мы преобразуем векторизованные данные с помощью преобразователя tfidf -

input_tfidf = tfidf.transform(input_tc)

Мы будем прогнозировать категории вывода -

predictions = classifier.predict(input_tfidf)

Вывод генерируется следующим образом -

for sent, category in zip(input_data, predictions):
   print('\nInput Data:', sent, '\n Category:', \
      category_map[training_data.target_names[category]])

Предиктор категории генерирует следующий вывод -

Dimensions of training data: (2755, 39297)

Input Data: Discovery was a space shuttle
Category: Space

Input Data: Hindu, Christian, Sikh all are religions
Category: Religion

Input Data: We must have to drive safely
Category: Autos

Input Data: Puck is a disk made of rubber
Category: Hockey

Input Data: Television, Microwave, Refrigrated all uses electricity
Category: Electronics

Поиск пола

В этой постановке задачи классификатор будет обучен определять пол (мужской или женский) по именам. Нам нужно использовать эвристику для построения вектора признаков и обучения классификатора. Мы будем использовать помеченные данные из пакета scikit-learn. Ниже приведен код Python для создания средства поиска пола.

Импортируем необходимые пакеты -

import random

from nltk import NaiveBayesClassifier
from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names

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

def extract_features(word, N = 2):
   last_n_letters = word[-N:]
   return {'feature': last_n_letters.lower()}
	
if __name__=='__main__':

Создайте данные обучения, используя помеченные имена (мужские и женские), доступные в NLTK -

male_list = [(name, 'male') for name in names.words('male.txt')]
female_list = [(name, 'female') for name in names.words('female.txt')]
data = (male_list + female_list)

random.seed(5)
random.shuffle(data)

Теперь тестовые данные будут созданы следующим образом -

namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']

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

train_sample = int(0.8 * len(data))

Теперь нам нужно перебрать разную длину, чтобы можно было сравнить точность -

for i in range(1, 6):
   print('\nNumber of end letters:', i)
   features = [(extract_features(n, i), gender) for (n, gender) in data]
   train_data, test_data = features[:train_sample],
features[train_sample:]
   classifier = NaiveBayesClassifier.train(train_data)

Точность классификатора можно вычислить следующим образом:

accuracy_classifier = round(100 * nltk_accuracy(classifier, test_data), 2)
   print('Accuracy = ' + str(accuracy_classifier) + '%')

Теперь мы можем предсказать результат -

for name in namesInput:
   print(name, '==>', classifier.classify(extract_features(name, i)))

Вышеупомянутая программа сгенерирует следующий вывод -

Number of end letters: 1
Accuracy = 74.7%
Rajesh -> female
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 2
Accuracy = 78.79%
Rajesh -> male
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 3
Accuracy = 77.22%
Rajesh -> male
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 4
Accuracy = 69.98%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 5
Accuracy = 64.63%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

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

Тематическое моделирование: выявление закономерностей в текстовых данных

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

Мы можем использовать технику тематического моделирования в следующих сценариях -

Текстовая классификация

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

Рекомендательные системы

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

Алгоритмы тематического моделирования

Тематическое моделирование может быть реализовано с помощью алгоритмов. Алгоритмы следующие -

Скрытое распределение Дирихле (LDA)

Этот алгоритм является наиболее популярным для тематического моделирования. Он использует вероятностные графические модели для реализации тематического моделирования. Нам нужно импортировать пакет gensim в Python для использования алгоритма LDA.

Скрытый семантический анализ (LDA) или скрытое семантическое индексирование (LSI)

Этот алгоритм основан на линейной алгебре. В основном он использует концепцию SVD (Разложение по сингулярным значениям) в матрице терминов документа.

Неотрицательная матричная факторизация (NMF)

Он также основан на линейной алгебре.

Все вышеперечисленные алгоритмы тематического моделирования будут иметь number of topics как параметр, Document-Word Matrix как вход и WTM (Word Topic Matrix) & TDM (Topic Document Matrix) как выход.

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

Введение

Данные временных рядов означают данные, которые находятся в серии определенных временных интервалов. Если мы хотим построить предсказание последовательности в машинном обучении, то нам придется иметь дело с последовательными данными и временем. Серийные данные - это абстракция последовательных данных. Упорядочивание данных - важная особенность последовательных данных.

Основная концепция анализа последовательности или анализа временных рядов

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

Example

Рассмотрим следующий пример, чтобы понять предсказание последовательности. ВотA,B,C,D являются заданными значениями, и вы должны предсказать значение E с использованием модели прогнозирования последовательности.

Установка полезных пакетов

Для анализа данных временных рядов с использованием Python нам необходимо установить следующие пакеты:

Панды

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

pip install pandas

Если вы используете Anaconda и хотите установить с помощью conda менеджер пакетов, вы можете использовать следующую команду -

conda install -c anaconda pandas

хмммучиться

Это библиотека с открытым исходным кодом с лицензией BSD, которая состоит из простых алгоритмов и моделей для изучения скрытых марковских моделей (HMM) в Python. Вы можете установить его с помощью следующей команды -

pip install hmmlearn

Если вы используете Anaconda и хотите установить с помощью conda менеджер пакетов, вы можете использовать следующую команду -

conda install -c omnia hmmlearn

PyStruct

Это структурированная библиотека для обучения и прогнозирования. Алгоритмы обучения, реализованные в PyStruct, имеют такие имена, как условные случайные поля (CRF), марковские случайные сети с максимальным запасом (M3N) или машины структурных опорных векторов. Вы можете установить его с помощью следующей команды -

pip install pystruct

CVXOPT

Используется для выпуклой оптимизации на основе языка программирования Python. Это также бесплатный программный пакет. Вы можете установить его с помощью следующей команды -

pip install cvxopt

Если вы используете Anaconda и хотите установить с помощью conda менеджер пакетов, вы можете использовать следующую команду -

conda install -c anaconda cvdoxt

Pandas: обработка, нарезка и извлечение статистики из данных временных рядов

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

• Создайте диапазон дат, используя pd.date_range пакет

• Индексируйте панды с датами, используя pd.Series пакет

• Выполните повторную выборку с помощью ts.resample пакет

• Измените частоту

пример

В следующем примере показано, как обрабатывать и нарезать данные временных рядов с помощью Pandas. Обратите внимание, что здесь мы используем данные о месячных арктических колебаниях, которые можно загрузить с сайта month.ao.index.b50.current.ascii и преобразовать в текстовый формат для нашего использования.

Обработка данных временных рядов

Для обработки данных временных рядов вам необходимо выполнить следующие шаги:

Первый шаг включает в себя импорт следующих пакетов -

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

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

def read_data(input_file):
   input_data = np.loadtxt(input_file, delimiter = None)

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

dates = pd.date_range('1950-01', periods = input_data.shape[0], freq = 'M')

На этом этапе мы создаем данные временных рядов с помощью Pandas Series, как показано ниже -

output = pd.Series(input_data[:, index], index = dates)	
return output
	
if __name__=='__main__':

Введите путь к входному файлу, как показано здесь -

input_file = "/Users/admin/AO.txt"

Теперь преобразуйте столбец в формат таймсерий, как показано здесь -

timeseries = read_data(input_file)

Наконец, постройте и визуализируйте данные, используя показанные команды -

plt.figure()
timeseries.plot()
plt.show()

Вы увидите графики, как показано на следующих изображениях -

Нарезка данных временного ряда

Нарезка включает получение только некоторой части данных временного ряда. В качестве части примера мы разрезаем данные только с 1980 по 1990 год. Обратите внимание на следующий код, который выполняет эту задачу:

timeseries['1980':'1990'].plot()
   <matplotlib.axes._subplots.AxesSubplot at 0xa0e4b00>

plt.show()

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

Извлечение статистики из данных временных рядов

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

Значить

Вы можете использовать mean() функция для нахождения среднего, как показано здесь -

timeseries.mean()

Тогда результат, который вы увидите для обсуждаемого примера:

-0.11143128165238671

Максимум

Вы можете использовать max() функция для поиска максимума, как показано здесь -

timeseries.max()

Тогда результат, который вы увидите для обсуждаемого примера:

3.4952999999999999

Минимум

Вы можете использовать функцию min () для поиска минимума, как показано здесь -

timeseries.min()

Тогда результат, который вы увидите для обсуждаемого примера:

-4.2656999999999998

Получение всего сразу

Если вы хотите рассчитывать всю статистику за раз, вы можете использовать describe() функция, как показано здесь -

timeseries.describe()

Тогда результат, который вы увидите для обсуждаемого примера:

count   817.000000
mean     -0.111431
std       1.003151
min      -4.265700
25%      -0.649430
50%      -0.042744
75%       0.475720
max       3.495300
dtype: float64

Повторная выборка

Вы можете выполнить повторную выборку данных с другой временной частотой. Два параметра для выполнения повторной выборки:

• Временной период
• Method

Повторная выборка с помощью mean ()

Вы можете использовать следующий код для повторной выборки данных с помощью метода mean (), который является методом по умолчанию:

timeseries_mm = timeseries.resample("A").mean()
timeseries_mm.plot(style = 'g--')
plt.show()

Затем вы можете наблюдать следующий график как результат передискретизации с использованием mean () -

Повторная выборка с использованием медианы ()

Вы можете использовать следующий код для повторной выборки данных с помощью median()метод -

timeseries_mm = timeseries.resample("A").median()
timeseries_mm.plot()
plt.show()

Затем вы можете наблюдать следующий график как результат повторной выборки с median () -

Скользящее среднее

Вы можете использовать следующий код для расчета скользящего (скользящего) среднего -

timeseries.rolling(window = 12, center = False).mean().plot(style = '-g')
plt.show()

Затем вы можете наблюдать следующий график как результат скользящего (скользящего) среднего -

Анализ последовательных данных с помощью скрытой марковской модели (HMM)

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

Скрытая марковская модель (HMM)

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

Математически HMM состоит из следующих переменных -

Состояния (S)

Это набор скрытых или скрытых состояний, присутствующих в HMM. Обозначается он S.

Выходные символы (O)

Это набор возможных выходных символов, присутствующих в HMM. Обозначается O.

Матрица вероятности перехода между состояниями (A)

Это вероятность перехода из одного состояния в каждое из других состояний. Обозначается А.

Матрица вероятности выбросов при наблюдении (B)

Это вероятность появления / наблюдения символа в определенном состоянии. Обозначается буквой B.

Матрица априорной вероятности (Π)

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

Следовательно, HMM можно определить как = (S,O,A,B,),

где,

• S = {s₁,s₂,…,s_N} набор из N возможных состояний,
• O = {o₁,o₂,…,o_M} набор из M возможных символов наблюдения,
• А - это NN Матрица вероятности перехода состояния (TPM),
• B - это NM наблюдение или матрица вероятности выбросов (EPM),
• π - N-мерный вектор распределения вероятностей начального состояния.

Пример: анализ данных фондового рынка

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

Импортируйте необходимые пакеты, как показано ниже -

import datetime
import warnings

Теперь используйте данные фондового рынка из matpotlib.finance пакет, как показано здесь -

import numpy as np
from matplotlib import cm, pyplot as plt
from matplotlib.dates import YearLocator, MonthLocator
try:
   from matplotlib.finance import quotes_historical_yahoo_och1
except ImportError:
   from matplotlib.finance import (
      quotes_historical_yahoo as quotes_historical_yahoo_och1)

from hmmlearn.hmm import GaussianHMM

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

start_date = datetime.date(1995, 10, 10)
end_date = datetime.date(2015, 4, 25)
quotes = quotes_historical_yahoo_och1('INTC', start_date, end_date)

На этом этапе мы будем извлекать котировки закрытия каждый день. Для этого используйте следующую команду -

closing_quotes = np.array([quote[2] for quote in quotes])

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

volumes = np.array([quote[5] for quote in quotes])[1:]

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

diff_percentages = 100.0 * np.diff(closing_quotes) / closing_quotes[:-]
dates = np.array([quote[0] for quote in quotes], dtype = np.int)[1:]
training_data = np.column_stack([diff_percentages, volumes])

На этом этапе создайте и обучите гауссовский HMM. Для этого используйте следующий код -

hmm = GaussianHMM(n_components = 7, covariance_type = 'diag', n_iter = 1000)
with warnings.catch_warnings():
   warnings.simplefilter('ignore')
   hmm.fit(training_data)

Теперь сгенерируйте данные, используя модель HMM, используя показанные команды -

num_samples = 300
samples, _ = hmm.sample(num_samples)

Наконец, на этом этапе мы строим и визуализируем процентную разницу и объем продаваемых акций в виде выходных данных в виде графика.

Используйте следующий код для построения и визуализации процентов разницы -

plt.figure()
plt.title('Difference percentages')
plt.plot(np.arange(num_samples), samples[:, 0], c = 'black')

Используйте следующий код для построения графика и визуализации объема торгуемых акций:

plt.figure()
plt.title('Volume of shares')
plt.plot(np.arange(num_samples), samples[:, 1], c = 'black')
plt.ylim(ymin = 0)
plt.show()

В этой главе мы узнаем о распознавании речи с использованием ИИ с Python.

Речь - это самое основное средство общения взрослых людей. Основная цель обработки речи - обеспечить взаимодействие человека и машины.

Система обработки речи имеет в основном три задачи:

• First, распознавание речи, которое позволяет машине улавливать слова, фразы и предложения, которые мы говорим

• Second, обработка естественного языка, позволяющая машине понимать, о чем мы говорим, и

• Third, синтез речи, чтобы машина могла говорить.

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

Создание распознавателя речи

Распознавание речи или автоматическое распознавание речи (ASR) находится в центре внимания проектов искусственного интеллекта, таких как робототехника. Без ASR невозможно представить когнитивного робота, взаимодействующего с человеком. Однако создать распознаватель речи непросто.

Трудности в разработке системы распознавания речи

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

• Size of the vocabulary- Размер словарного запаса влияет на легкость разработки ASR. Для лучшего понимания рассмотрите следующие объемы словарного запаса.

• Небольшой словарный запас состоит из 2-100 слов, например, как в системе голосового меню.

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

• Большой словарный запас состоит из нескольких десятков тысяч слов, как в общем задании на диктовку.

Обратите внимание: чем больше словарный запас, тем труднее выполнять распознавание.

• Channel characteristics- Качество канала также является важным параметром. Например, человеческая речь имеет широкую полосу пропускания с полным частотным диапазоном, тогда как телефонная речь состоит из узкой полосы пропускания с ограниченным частотным диапазоном. Учтите, что в последнем случае сложнее.

• Speaking mode- Простота разработки ASR также зависит от режима разговора, то есть от того, идет ли речь в режиме изолированного слова, в режиме связного слова или в режиме непрерывной речи. Обратите внимание, что непрерывную речь труднее распознать.

• Speaking style- Прочитанная речь может быть формальной или спонтанной и разговорной с повседневным стилем. Последнее распознать сложнее.

• Speaker dependency- Речь может быть зависимой от говорящего, адаптивной или независимой. Сложнее всего построить независимый динамик.

• Type of noise- Шум - еще один фактор, который следует учитывать при разработке ASR. Отношение сигнал / шум может быть в различных диапазонах, в зависимости от акустической среды, в которой наблюдается меньше фонового шума или больше -

• Если отношение сигнал / шум больше 30 дБ, это считается высоким диапазоном.

• Если отношение сигнал / шум составляет от 30 до 10 дБ, это считается средним SNR.

• Если отношение сигнал / шум меньше 10 дБ, это считается низким диапазоном.

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

• Microphone characteristics- Качество микрофона может быть хорошим, средним или ниже среднего. Также может варьироваться расстояние между ртом и микрофоном. Эти факторы также следует учитывать для систем распознавания.

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

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

Визуализация аудиосигналов - чтение из файла и работа с ним

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

Запись

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

Отбор проб

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

пример

В следующем примере показан пошаговый подход к анализу аудиосигнала с использованием Python, который хранится в файле. Частота этого аудиосигнала составляет 44 100 Гц.

Импортируйте необходимые пакеты, как показано здесь -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

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

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

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

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

Этот шаг включает в себя нормализацию сигнала, как показано ниже -

audio_signal = audio_signal / np.power(2, 15)

На этом этапе мы извлекаем первые 100 значений из этого сигнала для визуализации. Для этого используйте следующие команды -

audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)

Теперь визуализируйте сигнал, используя команды, приведенные ниже -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()

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

Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds

Характеристика аудиосигнала: преобразование в частотную область

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

пример

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

Импортируйте необходимые пакеты, как показано здесь -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

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

frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")

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

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

На этом этапе нам нужно нормализовать сигнал, как показано в следующей команде -

audio_signal = audio_signal / np.power(2, 15)

Этот шаг включает извлечение длины и половинной длины сигнала. Для этого используйте следующие команды -

length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)

Теперь нам нужно применить математические инструменты для преобразования в частотную область. Здесь мы используем преобразование Фурье.

signal_frequency = np.fft.fft(audio_signal)

Теперь сделайте нормализацию сигнала частотной области и возведите его в квадрат -

signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2

Затем извлеките длину и половину длины преобразованного по частоте сигнала -

len_fts = len(signal_frequency)

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

if length_signal % 2:
   signal_frequency[1:len_fts] *= 2
else:
   signal_frequency[1:len_fts-1] *= 2

Теперь извлеките мощность в децибалах (дБ) -

signal_power = 10 * np.log10(signal_frequency)

Настройте частоту в кГц для оси X -

x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0

Теперь представьте себе характеристику сигнала следующим образом -

plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()

Вы можете наблюдать выходной график приведенного выше кода, как показано на изображении ниже -

Генерация монотонного аудиосигнала

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

пример

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

Импортируйте необходимые пакеты, как показано -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write

Укажите файл, в котором должен быть сохранен выходной файл

output_file = 'audio_signal_generated.wav'

Теперь укажите параметры по вашему выбору, как показано -

duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi

На этом этапе мы можем сгенерировать аудиосигнал, как показано -

t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)

Теперь сохраните аудиофайл в выходном файле -

write(output_file, frequency_sampling, signal_scaled)

Извлеките первые 100 значений для нашего графика, как показано -

audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)

Теперь визуализируйте сгенерированный звуковой сигнал следующим образом -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()

Вы можете наблюдать за сюжетом, как показано на рисунке, приведенном здесь -

Извлечение функций из речи

Это наиболее важный шаг в создании распознавателя речи, потому что после преобразования речевого сигнала в частотную область мы должны преобразовать его в пригодную для использования форму вектора признаков. Для этой цели мы можем использовать различные методы извлечения функций, такие как MFCC, PLP, PLP-RASTA и т. Д.

пример

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

Импортируйте необходимые пакеты, как показано здесь -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

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

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

Обратите внимание, что здесь мы берем на анализ первые 15000 проб.

audio_signal = audio_signal[:15000]

Используйте методы MFCC и выполните следующую команду, чтобы извлечь функции MFCC:

features_mfcc = mfcc(audio_signal, frequency_sampling)

Теперь распечатайте параметры MFCC, как показано -

print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])

Теперь постройте и визуализируйте функции MFCC, используя команды, приведенные ниже -

features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

На этом этапе мы работаем с функциями банка фильтров, как показано -

Извлеките функции банка фильтров -

filterbank_features = logfbank(audio_signal, frequency_sampling)

Теперь распечатайте параметры набора фильтров.

print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])

Теперь постройте и визуализируйте функции банка фильтров.

filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()

В результате описанных выше шагов вы можете наблюдать следующие выходные данные: Рисунок 1 для MFCC и Рисунок 2 для банка фильтров.

Распознавание произнесенных слов

Распознавание речи означает, что когда люди говорят, машина их понимает. Здесь мы используем Google Speech API в Python, чтобы это произошло. Для этого нам нужно установить следующие пакеты -

• Pyaudio - Его можно установить с помощью pip install Pyaudio команда.

• SpeechRecognition - Этот пакет можно установить с помощью pip install SpeechRecognition.

• Google-Speech-API - Его можно установить с помощью команды pip install google-api-python-client.

пример

Обратите внимание на следующий пример, чтобы понять распознавание произносимых слов -

Импортируйте необходимые пакеты, как показано -

import speech_recognition as sr

Создайте объект, как показано ниже -

recording = sr.Recognizer()

Теперь Microphone() модуль примет голос как вход -

with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
   print("Please Say something:")
   audio = recording.listen(source)

Теперь API Google распознает голос и выдаст результат.

try:
   print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
   print(e)

Вы можете увидеть следующий результат -

Please Say Something:
You said:

Например, если вы сказали tutorialspoint.com, то система распознает его правильно следующим образом -

tutorialspoint.com

Эвристический поиск играет ключевую роль в искусственном интеллекте. В этой главе вы узнаете об этом подробно.

Концепция эвристического поиска в AI

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

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

Разница между неинформированным и информированным поиском

Есть два типа стратегий контроля или методов поиска: неосведомленные и информированные. Они подробно объяснены, как указано здесь -

Неинформированный поиск

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

Информированный поиск

Это также называется эвристическим поиском или эвристической стратегией управления. Он назван так, потому что есть дополнительная информация о состояниях. Эта дополнительная информация полезна для вычисления предпочтений среди дочерних узлов для исследования и расширения. С каждым узлом будет связана эвристическая функция. Best First Search (BFS), A *, Mean и Analysis - примеры информированного поиска.

Проблемы удовлетворения ограничений (CSP)

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

Проблема реального мира решается ограничением удовлетворенности

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

Решение алгебраического отношения

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

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

Обратите внимание, что перед написанием программы нам необходимо установить пакет Python с именем python-constraint. Вы можете установить его с помощью следующей команды -

pip install python-constraint

Следующие шаги показывают вам программу Python для решения алгебраической связи с использованием удовлетворения ограничений.

Импортируйте constraint пакет, используя следующую команду -

from constraint import *

Теперь создайте объект модуля с именем problem() как показано ниже -

problem = Problem()

Теперь определим переменные. Обратите внимание, что здесь у нас есть две переменные a и b, и мы определяем 10 как их диапазон, что означает, что мы получили решение в пределах первых 10 чисел.

problem.addVariable('a', range(10))
problem.addVariable('b', range(10))

Затем определите конкретное ограничение, которое мы хотим применить к этой проблеме. Обратите внимание, что здесь мы используем ограничениеa*2 = b.

problem.addConstraint(lambda a, b: a * 2 == b)

Теперь создайте объект getSolution() модуль, используя следующую команду -

solutions = problem.getSolutions()

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

print (solutions)

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

[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a': 1, 'b': 2}, {'a': 0, 'b': 0}]

Магический квадрат

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

Ниже приведено пошаговое выполнение простого кода Python для генерации магических квадратов.

Определите функцию с именем magic_square, как показано ниже -

def magic_square(matrix_ms):
   iSize = len(matrix_ms[0])
   sum_list = []

Следующий код показывает код для вертикали квадратов -

for col in range(iSize):
   sum_list.append(sum(row[col] for row in matrix_ms))

Следующий код показывает код для горизонтали квадратов -

sum_list.extend([sum (lines) for lines in matrix_ms])

Следующий код показывает код для горизонтали квадратов -

dlResult = 0
for i in range(0,iSize):
   dlResult +=matrix_ms[i][i]
sum_list.append(dlResult)
drResult = 0
for i in range(iSize-1,-1,-1):
   drResult +=matrix_ms[i][i]
sum_list.append(drResult)

if len(set(sum_list))>1:
   return False
return True

Теперь дайте значение матрицы и проверьте вывод -

print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))

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

print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))

Вы можете заметить, что результат будет True так как сумма - то же самое число, то есть 15 Вот.

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

Алгоритмы поиска

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

Как это устроено

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

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

Комбинационный поиск

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

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

Минимаксный алгоритм

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

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

Альфа-бета обрезка

Основная проблема с алгоритмом Minimax заключается в том, что он может исследовать те части дерева, которые не имеют отношения к делу, что приводит к неэффективной трате ресурсов. Следовательно, должна быть стратегия, чтобы решить, какая часть дерева релевантна, а какая нерелевантна, и оставить нерелевантную часть неисследованной. Альфа-бета-обрезка - одна из таких стратегий.

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

Алгоритм Негамакса

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

Создание ботов для игр

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

pip install easyAI

Бот для игры в последнюю оставшуюся монету

В этой игре будет куча монет. Каждый игрок должен взять определенное количество монет из этой стопки. Цель игры - не взять последнюю монету в стопке. Мы будем использовать классLastCoinStanding унаследованный от TwoPlayersGame класс easyAIбиблиотека. Следующий код показывает код Python для этой игры -

Импортируйте необходимые пакеты, как показано -

from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT

Теперь унаследуйте класс от TwoPlayerGame класс для обработки всех операций в игре -

class LastCoin_game(TwoPlayersGame):
   def __init__(self, players):

Теперь определите игроков и игрока, который собирается начать игру.

self.players = players
self.nplayer = 1

Теперь определите количество монет в игре, здесь мы используем 15 монет для игры.

self.num_coins = 15

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

self.max_coins = 4

Теперь нужно определить некоторые вещи, как показано в следующем коде. Определите возможные ходы.

def possible_moves(self):
   return [str(a) for a in range(1, self.max_coins + 1)]

Определите удаление монет

def make_move(self, move):
   self.num_coins -= int(move)

Определите, кто взял последнюю монету.

def win_game(self):
   return self.num_coins <= 0

Определите, когда остановить игру, то есть когда кто-то выиграет.

def is_over(self):
   return self.win()

Определите, как рассчитать оценку.

def score(self):
   return 100 if self.win_game() else 0

Определите количество монет, оставшихся в стопке.

def show(self):
   print(self.num_coins, 'coins left in the pile')
if __name__ == "__main__":
   tt = TT()
   LastCoin_game.ttentry = lambda self: self.num_coins

Решение игры с помощью следующего блока кода -

r, d, m = id_solve(LastCoin_game,
   range(2, 20), win_score=100, tt=tt)
print(r, d, m)

Решаем, кто начнет игру

game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()

Вы можете найти следующий вывод и простую игру в эту игру -

d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile

Бот для игры в крестики-нолики

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

Импортируйте пакеты, как показано -

from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player

Наследовать класс от TwoPlayerGame класс для обработки всех операций в игре -

class TicTacToe_game(TwoPlayersGame):
   def __init__(self, players):

Теперь определите игроков и игрока, который собирается начать игру -

self.players = players
self.nplayer = 1

Определите тип доски -

self.board = [0] * 9

Теперь нужно определить следующие вещи:

Определите возможные ходы

def possible_moves(self):
   return [x + 1 for x, y in enumerate(self.board) if y == 0]

Определите ход игрока -

def make_move(self, move):
   self.board[int(move) - 1] = self.nplayer

Чтобы усилить ИИ, определите, когда игрок делает ход -

def umake_move(self, move):
   self.board[int(move) - 1] = 0

Определите условие проигрыша, при котором у соперника три в ряд

def condition_for_lose(self):
   possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
      [1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
   return any([all([(self.board[z-1] == self.nopponent)
      for z in combination]) for combination in possible_combinations])

Определите чек на окончание игры

def is_over(self):
   return (self.possible_moves() == []) or self.condition_for_lose()

Показать текущее положение игроков в игре

def show(self):
   print('\n'+'\n'.join([' '.join([['.', 'O', 'X'][self.board[3*j + i]]
      for i in range(3)]) for j in range(3)]))

Подсчитайте оценки.

def scoring(self):
   return -100 if self.condition_for_lose() else 0

Определите основной метод для определения алгоритма и начала игры -

if __name__ == "__main__":
   algo = Negamax(7)
   TicTacToe_game([Human_Player(), AI_Player(algo)]).play()

Вы можете увидеть следующий результат и простую игру в эту игру -

. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .

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

Что такое искусственные нейронные сети (ИНС)

Искусственная нейронная сеть (ИНС) - это эффективная вычислительная система, центральная тема которой заимствована из аналогии с биологическими нейронными сетями. ИНС также называют искусственными нейронными системами, системами параллельной распределенной обработки и системами коннекционизма. ИНС приобретает большое количество единиц, которые связаны между собой по некоторому шаблону, чтобы обеспечить связь между ними. Эти блоки, также называемыеnodes или же neurons, - простые процессоры, которые работают параллельно.

Каждый нейрон связан с другим нейроном через connection link. Каждому соединительному звену соответствует вес, содержащий информацию о входном сигнале. Это наиболее полезная информация для нейронов при решении конкретной проблемы, посколькуweightобычно возбуждает или подавляет передаваемый сигнал. Каждый нейрон имеет свое внутреннее состояние, которое называетсяactivation signal. Выходные сигналы, которые создаются после объединения входных сигналов и правила активации, могут быть отправлены на другие блоки.

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

Установка полезных пакетов

Для создания нейронных сетей на Python мы можем использовать мощный пакет для нейронных сетей под названием NeuroLab. Это библиотека основных алгоритмов нейронных сетей с гибкими сетевыми конфигурациями и алгоритмами обучения для Python. Вы можете установить этот пакет с помощью следующей команды в командной строке -

pip install NeuroLab

Если вы используете среду Anaconda, используйте следующую команду для установки NeuroLab -

conda install -c labfabulous neurolab

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

В этом разделе давайте создадим несколько нейронных сетей на Python с помощью пакета NeuroLab.

Классификатор на основе персептрона

Персептроны - это строительные блоки ИНС. Если вы хотите узнать больше о Perceptron, вы можете перейти по ссылке --tificial_neural_network

Ниже приведено пошаговое выполнение кода Python для создания простого классификатора на основе перцептрона нейронной сети.

Импортируйте необходимые пакеты, как показано -

import matplotlib.pyplot as plt
import neurolab as nl

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

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Создайте сеть с 2 входами и 1 нейроном -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Теперь тренируйте сеть. Здесь мы используем правило дельты для обучения.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Теперь визуализируйте результат и постройте график -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

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

Одноуровневые нейронные сети

В этом примере мы создаем однослойную нейронную сеть, состоящую из независимых нейронов, действующих на входные данные для получения выходных данных. Обратите внимание, что мы используем текстовый файл с именемneural_simple.txt как наш вклад.

Импортируйте полезные пакеты, как показано -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Загрузите набор данных следующим образом -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

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

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Теперь разделите эти четыре столбца на 2 столбца данных и 2 метки -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Постройте входные данные, используя следующие команды -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Теперь определите минимальные и максимальные значения для каждого измерения, как показано здесь -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Затем определите количество нейронов в выходном слое следующим образом:

nn_output_layer = labels.shape[1]

Теперь определите однослойную нейронную сеть -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Обучите нейронную сеть с количеством эпох и скоростью обучения, как показано -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Теперь визуализируйте и нарисуйте прогресс тренировки, используя следующие команды -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Теперь используйте контрольные точки данных в приведенном выше классификаторе -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Вы можете найти результаты теста, как показано здесь -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Вы можете увидеть следующие графики как результат кода, который обсуждался до сих пор:

Многоуровневые нейронные сети

В этом примере мы создаем многослойную нейронную сеть, состоящую из более чем одного слоя, для извлечения базовых шаблонов в обучающих данных. Эта многослойная нейронная сеть будет работать как регрессор. Мы собираемся сгенерировать некоторые точки данных на основе уравнения: y = 2x ² +8.

Импортируйте необходимые пакеты, как показано -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Создайте некоторую точку данных на основе вышеупомянутого уравнения -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Теперь измените этот набор данных следующим образом:

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Визуализируйте и постройте набор входных данных, используя следующие команды -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Теперь создайте нейронную сеть с двумя скрытыми слоями с neurolab с участием ten нейроны в первом скрытом слое, six во втором скрытом слое и one в выходном слое.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Теперь используйте алгоритм градиентного обучения -

neural_net.trainf = nl.train.train_gd

Теперь обучите сеть с целью изучения данных, сгенерированных выше -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Теперь запустите нейронные сети на обучающих точках данных -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Теперь сюжет и задача визуализации -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Теперь мы будем отображать фактический и прогнозируемый результат -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

В результате выполнения приведенных выше команд вы можете наблюдать графики, как показано ниже -

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

Основы обучения с подкреплением

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

Этот процесс обучения похож на обучение с учителем, но у нас может быть очень мало информации. На следующем рисунке представлена ​​блок-схема обучения с подкреплением -

Строительные блоки: окружающая среда и агент

Среда и агент являются основными строительными блоками обучения с подкреплением в ИИ. В этом разделе они подробно обсуждаются -

Агент

Агент - это все, что может воспринимать окружающую среду с помощью датчиков и воздействовать на нее с помощью эффекторов.

• А human agent имеет органы чувств, такие как глаза, уши, нос, язык и кожу, параллельные датчикам, и другие органы, такие как руки, ноги, рот, для эффекторов.

• А robotic agent заменяет камеры и инфракрасные дальномеры для датчиков, а также различные двигатели и исполнительные механизмы для эффекторов.

• А software agent закодировал битовые строки как свои программы и действия.

Терминология агента

Следующие термины чаще используются в обучении с подкреплением в ИИ:

• Performance Measure of Agent - Это критерии, которые определяют, насколько успешен агент.

• Behavior of Agent - Это действие, которое агент выполняет после любой заданной последовательности восприятий.

• Percept - Это перцепционные входы агента в данный момент.

• Percept Sequence - Это история всего, что агент воспринимал до настоящего времени.

• Agent Function - Это карта от последовательности предписаний к действию.

Окружающая обстановка

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

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

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

Свойства окружающей среды

Среда имеет множество свойств, как описано ниже -

• Discrete/Continuous- Если существует ограниченное количество различных, четко определенных состояний среды, среда дискретна, в противном случае она непрерывна. Например, шахматы - это дискретная среда, а вождение - непрерывная среда.

• Observable/Partially Observable- Если возможно определить полное состояние окружающей среды в каждый момент времени с помощью восприятий, это можно наблюдать; в противном случае это наблюдается лишь частично.

• Static/Dynamic- Если среда не меняется во время действия агента, то она статична; в противном случае это динамично.

• Single agent/Multiple agents - Окружающая среда может содержать других агентов, которые могут быть того же самого или другого типа, что и агент.

• Accessible/Inaccessible- Если сенсорный аппарат агента может иметь доступ к полному состоянию окружающей среды, тогда среда доступна этому агенту; в противном случае он недоступен.

• Deterministic/Non-deterministic- Если следующее состояние среды полностью определяется текущим состоянием и действиями агента, то среда является детерминированной; в противном случае он недетерминирован.

• Episodic/Non-episodic- В эпизодической среде каждый эпизод состоит из того, что агент воспринимает, а затем действует. Качество его действия зависит как раз от самого эпизода. Последующие эпизоды не зависят от действий в предыдущих эпизодах. Эпизодические среды намного проще, потому что агенту не нужно думать наперед.

Создание среды с помощью Python

Для создания агента обучения с подкреплением мы будем использовать OpenAI Gym пакет, который можно установить с помощью следующей команды -

pip install gym

В тренажерном зале OpenAI есть различные среды, которые можно использовать для различных целей. Немногие из нихCartpole-v0, Hopper-v1, и MsPacman-v0. Им нужны разные двигатели. Подробная документацияOpenAI Gym можно найти на https://gym.openai.com/docs/#environments.

В следующем коде показан пример кода Python для среды cartpole-v0:

import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
   env.render()
   env.step(env.action_space.sample())

Подобным образом вы можете сконструировать и другие среды.

Создание обучающего агента с помощью Python

Для создания агента обучения с подкреплением мы будем использовать OpenAI Gym пакет, как показано -

import gym
env = gym.make('CartPole-v0')
for _ in range(20):
   observation = env.reset()
   for i in range(100):
      env.render()
      print(observation)
      action = env.action_space.sample()
      observation, reward, done, info = env.step(action)
      if done:
         print("Episode finished after {} timesteps".format(i+1))
         break

Обратите внимание, что тележка может балансировать сама.

В этой главе подробно рассматриваются генетические алгоритмы ИИ.

Что такое генетические алгоритмы?

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

ГА были разработаны Джоном Холландом и его студентами и коллегами из Мичиганского университета, в первую очередь Дэвидом Э. Голдбергом. С тех пор его успешно опробовали на различных задачах оптимизации.

В GA у нас есть набор возможных решений данной проблемы. Затем эти растворы подвергаются рекомбинации и мутации (как в естественной генетике), производят новых детей, и этот процесс повторяется для разных поколений. Каждому индивиду (или возможному решению) присваивается значение пригодности (на основе его значения целевой функции), а более приспособленные индивидуумы получают более высокий шанс спариться и уступитьfitterлиц. Это соответствует дарвиновской теорииSurvival of the Fittest.

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

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

Как использовать GA для решения задач оптимизации?

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

Этапы механизма GA для процесса оптимизации

Ниже приводится последовательность шагов механизма GA при использовании для оптимизации задач.

• Шаг 1 - Сгенерируйте начальную популяцию случайным образом.

• Шаг 2 - Выберите исходное решение с наилучшими значениями пригодности.

• Шаг 3 - Перекомбинируйте выбранные решения, используя операторы мутации и кроссовера.

• Шаг 4 - Вставьте потомство в популяцию.

• Шаг 5 - Теперь, если условие остановки выполнено, верните решение с наилучшим значением пригодности. В противном случае перейдите к шагу 2.

Установка необходимых пакетов

Для решения проблемы с помощью генетических алгоритмов в Python мы собираемся использовать мощный пакет для GA под названием DEAP. Это библиотека новой эволюционной вычислительной среды для быстрого прототипирования и тестирования идей. Мы можем установить этот пакет с помощью следующей команды в командной строке -

pip install deap

Если вы используете anaconda среда, то для установки deap можно использовать следующую команду -

conda install -c conda-forge deap

Реализация решений с использованием генетических алгоритмов

В этом разделе объясняется реализация решений с использованием генетических алгоритмов.

Создание битовых комбинаций

В следующем примере показано, как сгенерировать битовую строку, содержащую 15 единиц, на основе One Max проблема.

Импортируйте необходимые пакеты, как показано -

import random
from deap import base, creator, tools

Определите функцию оценки. Это первый шаг к созданию генетического алгоритма.

def eval_func(individual):
   target_sum = 15
   return len(individual) - abs(sum(individual) - target_sum),

Теперь создайте набор инструментов с правильными параметрами -

def create_toolbox(num_bits):
   creator.create("FitnessMax", base.Fitness, weights=(1.0,))
   creator.create("Individual", list, fitness=creator.FitnessMax)

Инициализировать набор инструментов

toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat, creator.Individual,
   toolbox.attr_bool, num_bits)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

Зарегистрируйте оператора оценки -

toolbox.register("evaluate", eval_func)

Теперь зарегистрируйте оператор кроссовера -

toolbox.register("mate", tools.cxTwoPoint)

Зарегистрируйте оператор мутации -

toolbox.register("mutate", tools.mutFlipBit, indpb = 0.05)

Определите оператора разведения -

toolbox.register("select", tools.selTournament, tournsize = 3)
return toolbox
if __name__ == "__main__":
   num_bits = 45
   toolbox = create_toolbox(num_bits)
   random.seed(7)
   population = toolbox.population(n = 500)
   probab_crossing, probab_mutating = 0.5, 0.2
   num_generations = 10
   print('\nEvolution process starts')

Оцените все население -

fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
   ind.fitness.values = fit
print('\nEvaluated', len(population), 'individuals')

Создавайте и повторяйте из поколения в поколение -

for g in range(num_generations):
   print("\n- Generation", g)

Выбор людей следующего поколения -

offspring = toolbox.select(population, len(population))

Теперь клонируйте выбранных людей -

offspring = list(map(toolbox.clone, offspring))

Примените кроссовер и мутацию к потомству -

for child1, child2 in zip(offspring[::2], offspring[1::2]):
   if random.random() < probab_crossing:
   toolbox.mate(child1, child2)

Удалить значение пригодности для ребенка

del child1.fitness.values
del child2.fitness.values

Теперь примените мутацию -

for mutant in offspring:
   if random.random() < probab_mutating:
   toolbox.mutate(mutant)
   del mutant.fitness.values

Оцените людей с инвалидностью -

invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
fitnesses = map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
   ind.fitness.values = fit
print('Evaluated', len(invalid_ind), 'individuals')

А теперь замените популяцию особью следующего поколения -

population[:] = offspring

Распечатайте статистику по текущим поколениям -

fits = [ind.fitness.values[0] for ind in population]
length = len(population)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
print('Min =', min(fits), ', Max =', max(fits))
print('Average =', round(mean, 2), ', Standard deviation =',
round(std, 2))
print("\n- Evolution ends")

Распечатайте окончательный результат -

best_ind = tools.selBest(population, 1)[0]
   print('\nBest individual:\n', best_ind)
   print('\nNumber of ones:', sum(best_ind))
Following would be the output:
Evolution process starts
Evaluated 500 individuals
- Generation 0
Evaluated 295 individuals
Min = 32.0 , Max = 45.0
Average = 40.29 , Standard deviation = 2.61
- Generation 1
Evaluated 292 individuals
Min = 34.0 , Max = 45.0
Average = 42.35 , Standard deviation = 1.91
- Generation 2
Evaluated 277 individuals
Min = 37.0 , Max = 45.0
Average = 43.39 , Standard deviation = 1.46
… … … …
- Generation 9
Evaluated 299 individuals
Min = 40.0 , Max = 45.0
Average = 44.12 , Standard deviation = 1.11
- Evolution ends
Best individual:
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 
 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1]
Number of ones: 15

Проблема регрессии символов

Это одна из самых известных проблем генетического программирования. Все задачи символьной регрессии используют произвольное распределение данных и пытаются подогнать наиболее точные данные с помощью символьной формулы. Обычно такая мера, как RMSE (среднеквадратическая ошибка), используется для измерения физической подготовки человека. Это классическая задача регрессора, и здесь мы используем уравнение5x³-6x²+8x=1. Нам нужно выполнить все шаги, указанные в приведенном выше примере, но основная часть будет заключаться в создании примитивных наборов, поскольку они являются строительными блоками для отдельных лиц, чтобы можно было начать оценку. Здесь мы будем использовать классический набор примитивов.

Следующий код Python подробно объясняет это -

import operator
import math
import random
import numpy as np
from deap import algorithms, base, creator, tools, gp
def division_operator(numerator, denominator):
   if denominator == 0:
      return 1
   return numerator / denominator
def eval_func(individual, points):
   func = toolbox.compile(expr=individual)
   return math.fsum(mse) / len(points),
def create_toolbox():
   pset = gp.PrimitiveSet("MAIN", 1)
   pset.addPrimitive(operator.add, 2)
   pset.addPrimitive(operator.sub, 2)
   pset.addPrimitive(operator.mul, 2)
   pset.addPrimitive(division_operator, 2)
   pset.addPrimitive(operator.neg, 1)
   pset.addPrimitive(math.cos, 1)
   pset.addPrimitive(math.sin, 1)
   pset.addEphemeralConstant("rand101", lambda: random.randint(-1,1))
   pset.renameArguments(ARG0 = 'x')
   creator.create("FitnessMin", base.Fitness, weights = (-1.0,))
   creator.create("Individual",gp.PrimitiveTree,fitness=creator.FitnessMin)
   toolbox = base.Toolbox()
   toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=2)
   toolbox.expr)
   toolbox.register("population",tools.initRepeat,list, toolbox.individual)
   toolbox.register("compile", gp.compile, pset = pset)
   toolbox.register("evaluate", eval_func, points = [x/10. for x in range(-10,10)])
   toolbox.register("select", tools.selTournament, tournsize = 3)
   toolbox.register("mate", gp.cxOnePoint)
   toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
   toolbox.register("mutate", gp.mutUniform, expr = toolbox.expr_mut, pset = pset)
   toolbox.decorate("mate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
   toolbox.decorate("mutate", gp.staticLimit(key = operator.attrgetter("height"), max_value = 17))
   return toolbox
if __name__ == "__main__":
   random.seed(7)
   toolbox = create_toolbox()
   population = toolbox.population(n = 450)
   hall_of_fame = tools.HallOfFame(1)
   stats_fit = tools.Statistics(lambda x: x.fitness.values)
   stats_size = tools.Statistics(len)
   mstats = tools.MultiStatistics(fitness=stats_fit, size = stats_size)
   mstats.register("avg", np.mean)
   mstats.register("std", np.std)
   mstats.register("min", np.min)
   mstats.register("max", np.max)
   probab_crossover = 0.4
   probab_mutate = 0.2
   number_gen = 10
   population, log = algorithms.eaSimple(population, toolbox,
      probab_crossover, probab_mutate, number_gen,
      stats = mstats, halloffame = hall_of_fame, verbose = True)

Обратите внимание, что все основные шаги такие же, как и при генерации битовых комбинаций. Эта программа даст нам результат в виде min, max, std (стандартное отклонение) после 10 поколений.

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

Компьютерное зрение

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

Иерархия компьютерного зрения

Компьютерное зрение делится на три основные категории:

• Low-level vision - Он включает образ процесса для извлечения признаков.

• Intermediate-level vision - Он включает в себя распознавание объектов и интерпретацию 3D-сцены

• High-level vision - Он включает концептуальное описание сцены, например, действия, намерения и поведения.

Компьютерное зрение против обработки изображений

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

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

Приложения

Компьютерное зрение находит применение в следующих областях -

Robotics

• Локализация-определение местоположения робота автоматически

• Navigation

• Избегание препятствий

• Монтаж (вставка в отверстие, сварка, покраска)

• Манипуляции (например, робот-манипулятор PUMA)

• Human Robot Interaction (HRI): интеллектуальная робототехника для взаимодействия с людьми и обслуживания людей

Medicine

• Классификация и обнаружение (например, классификация поражения или клеток и обнаружение опухоли)

• 2D / 3D сегментация

• 3D-реконструкция человеческого органа (МРТ или УЗИ)

• Роботизированная хирургия под контролем зрения

Security

• Биометрия (радужная оболочка, отпечаток пальца, распознавание лица)
• Наблюдение, обнаруживающее определенные подозрительные действия или поведение

Transportation

• Автономный автомобиль
• Безопасность, например, мониторинг бдительности водителя

Industrial Automation Application

• Производственный контроль (обнаружение дефектов)
• Assembly
• Считывание штрих-кода и этикеток на упаковке
• Сортировка объектов
• Понимание документа (например, OCR)

Установка полезных пакетов

Для компьютерного зрения с Python вы можете использовать популярную библиотеку под названием OpenCV(Компьютерное зрение с открытым исходным кодом). Это библиотека функций программирования, в основном предназначенных для компьютерного зрения в реальном времени. Он написан на C ++, а его основной интерфейс - на C ++. Вы можете установить этот пакет с помощью следующей команды -

pip install opencv_python-X.X-cp36-cp36m-winX.whl

Здесь X представляет версию Python, установленную на вашем компьютере, а также имеющуюся у вас win32 или 64-разрядную версию.

Если вы используете anaconda среда, затем используйте следующую команду для установки OpenCV -

conda install -c conda-forge opencv

Чтение, запись и отображение изображения

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

Функции OpenCV для чтения, отображения и записи файла изображения

OpenCV предоставляет для этой цели следующие функции:

• imread() function- Это функция для чтения изображения. OpenCV imread () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

• imshow() function- Это функция для показа изображения в окне. Окно автоматически подгоняется под размер изображения. OpenCV imshow () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

• imwrite() function- Это функция для записи изображения. OpenCV imwrite () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

пример

В этом примере показан код Python для чтения изображения в одном формате - отображения его в окне и записи того же изображения в другом формате. Рассмотрим шаги, показанные ниже -

Импортируйте пакет OpenCV, как показано -

import cv2

Теперь для чтения конкретного изображения используйте функцию imread () -

image = cv2.imread('image_flower.jpg')

Для показа изображения используйте imshow()функция. Имя окна, в котором вы можете увидеть изображение, будетimage_flower.

cv2.imshow('image_flower',image)
cv2.destroyAllwindows()

Теперь мы можем записать то же изображение в другой формат, скажем .png, используя функцию imwrite () -

cv2.imwrite('image_flower.png',image)

Вывод True означает, что изображение было успешно записано как файл .png также в той же папке.

True

Примечание. Функция destroyallWindows () просто уничтожает все созданные нами окна.

Преобразование цветового пространства

В OpenCV изображения не сохраняются с использованием обычного цвета RGB, а хранятся в обратном порядке, то есть в порядке BGR. Следовательно, цветовой код по умолчанию при чтении изображения - BGR. ВcvtColor() функция преобразования цвета для преобразования изображения из одного цветового кода в другой.

пример

Рассмотрим этот пример для преобразования изображения из BGR в оттенки серого.

Импортируйте OpenCV пакет, как показано -

import cv2

Теперь для чтения конкретного изображения используйте функцию imread () -

image = cv2.imread('image_flower.jpg')

Теперь, если мы увидим это изображение, используя imshow() функция, то мы видим, что это изображение находится в BGR.

cv2.imshow('BGR_Penguins',image)

Теперь используйте cvtColor() функция для преобразования этого изображения в оттенки серого.

image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray_penguins',image)

Обнаружение края

Люди, увидев грубый набросок, могут легко узнать многие типы объектов и их позы. Вот почему края играют важную роль в жизни людей, а также в приложениях компьютерного зрения. OpenCV предоставляет очень простую и полезную функцию под названиемCanny()для обнаружения краев.

пример

В следующем примере показано четкое обозначение краев.

Импортируйте пакет OpenCV, как показано -

import cv2
import numpy as np

Теперь, чтобы прочитать конкретное изображение, используйте imread() функция.

image = cv2.imread('Penguins.jpg')

Теперь используйте Canny () функция определения краев уже прочитанного изображения.

cv2.imwrite(‘edges_Penguins.jpg’,cv2.Canny(image,200,300))

Теперь для отображения изображения с краями используйте функцию imshow ().

cv2.imshow(‘edges’, cv2.imread(‘‘edges_Penguins.jpg’))

Эта программа Python создаст изображение с именем edges_penguins.jpg с обнаружением края.

Распознавание лиц

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

Каскадные данные Хаара

Нам нужны данные для использования каскадного классификатора Хаара. Вы можете найти эти данные в нашем пакете OpenCV. После установки OpenCv вы можете увидеть имя папкиhaarcascades. Для другого приложения будут файлы .xml. Теперь скопируйте их все для другого использования и вставьте затем в новую папку в текущем проекте.

Example

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

Импортируйте OpenCV пакет, как показано -

import cv2
import numpy as np

Теперь используйте HaarCascadeClassifier для определения лица -

face_detection=
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/
haarcascade_frontalface_default.xml')

Теперь, чтобы прочитать конкретное изображение, используйте imread() функция -

img = cv2.imread('AB.jpg')

Теперь преобразуйте его в оттенки серого, потому что он принимает серые изображения -

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Теперь, используя face_detection.detectMultiScale, выполнить фактическое обнаружение лица

faces = face_detection.detectMultiScale(gray, 1.3, 5)

Теперь нарисуйте прямоугольник вокруг всего лица -

for (x,y,w,h) in faces:
   img = cv2.rectangle(img,(x,y),(x+w, y+h),(255,0,0),3)
cv2.imwrite('Face_AB.jpg',img)

Эта программа Python создаст изображение с именем Face_AB.jpg с распознаванием лиц, как показано

Обнаружение глаз

Обнаружение глаз - еще одно увлекательное приложение компьютерного зрения, которое делает его более реалистичным и футуристичным. OpenCV имеет встроенное средство для обнаружения глаз. Мы собираемся использоватьHaar cascade классификатор для обнаружения глаз.

пример

В следующем примере показан код Python, использующий Каскад Хаара для обнаружения лица Амитабха Бачана, показанный на следующем изображении:

Импортируйте пакет OpenCV, как показано -

import cv2
import numpy as np

Теперь используйте HaarCascadeClassifier для определения лица -

eye_cascade = cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/haarcascade_eye.xml')

Теперь, чтобы прочитать конкретное изображение, используйте imread() функция

img = cv2.imread('AB_Eye.jpg')

Теперь преобразуйте его в оттенки серого, потому что он принимает серые изображения -

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Теперь с помощью eye_cascade.detectMultiScale, выполнить фактическое обнаружение лица

eyes = eye_cascade.detectMultiScale(gray, 1.03, 5)

Теперь нарисуйте прямоугольник вокруг всего лица -

for (ex,ey,ew,eh) in eyes:
   img = cv2.rectangle(img,(ex,ey),(ex+ew, ey+eh),(0,255,0),2)
cv2.imwrite('Eye_AB.jpg',img)

Эта программа Python создаст изображение с именем Eye_AB.jpg с обнаружением глаз, как показано -

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

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

Машинное обучение против глубокого обучения

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

Зависимость данных

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

Зависимость от машины

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

Извлечение функций

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

Время исполнения

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

Подход к решению проблем

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

Сверточная нейронная сеть (CNN)

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

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

Обзор архитектуры CNN

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

В архитектуре CNN нейроны расположены в трех измерениях, называемых шириной, высотой и глубиной. Каждый нейрон в текущем слое подключен к небольшому участку выхода из предыдущего слоя. Это похоже на наложение×фильтр на входном изображении. Оно используетMфильтры, чтобы получить все подробности. ЭтиM фильтры - это экстракторы признаков, которые выделяют такие объекты, как края, углы и т.

Слои, используемые для построения CNN

Следующие слои используются для построения CNN -

• Input Layer - Необработанные данные изображения принимаются как есть.

• Convolutional Layer- Этот уровень является основным строительным блоком CNN, который выполняет большую часть вычислений. Этот слой вычисляет свертки между нейронами и различными участками на входе.

• Rectified Linear Unit Layer- Применяет функцию активации к выходу предыдущего слоя. Он добавляет нелинейности в сеть, так что ее можно хорошо обобщить на любой тип функции.

• Pooling Layer- Объединение помогает нам сохранять только важные части по мере нашего продвижения в сети. Слой объединения работает независимо на каждом слое глубины ввода и изменяет его размер в пространстве. Он использует функцию MAX.

• Fully Connected layer/Output layer - Этот слой вычисляет выходные оценки в последнем слое. Полученный результат имеет размер×× , где L - количество классов обучающего набора данных.

Установка полезных пакетов Python

Вы можете использовать Keras, который представляет собой высокоуровневый API нейронных сетей, написанный на Python и способный работать поверх TensorFlow, CNTK или Theno. Он совместим с Python 2.7-3.6. Вы можете узнать больше об этом изhttps://keras.io/.

Используйте следующие команды для установки keras -

pip install keras

На conda среды, вы можете использовать следующую команду -

conda install –c conda-forge keras

Построение линейного регрессора с использованием ИНС

В этом разделе вы узнаете, как построить линейный регрессор с использованием искусственных нейронных сетей. Вы можете использоватьKerasRegressorдля достижения этой цели. В этом примере мы используем набор данных о ценах на жилье в Бостоне с 13 числовыми значениями для свойств в Бостоне. Код Python для этого же показан здесь -

Импортируйте все необходимые пакеты, как показано -

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

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

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

Теперь разделите данные на входные и выходные переменные, то есть X и Y -

X = dataset[:,0:13]
Y = dataset[:,13]

Поскольку мы используем базовые нейронные сети, определите модель -

def baseline_model():

Теперь создайте модель следующим образом -

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

Далее скомпилируйте модель -

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

Теперь исправьте случайное начальное число для воспроизводимости следующим образом:

seed = 7
numpy.random.seed(seed)

Объект-оболочка Keras для использования в scikit-learn как оценка регрессии называется KerasRegressor. В этом разделе мы оценим эту модель со стандартизированным набором данных.

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

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

Классификатор изображений: применение глубокого обучения

Сверточные нейронные сети (CNN) решают проблему классификации изображений, то есть к какому классу принадлежит входное изображение. Вы можете использовать библиотеку глубокого обучения Keras. Обратите внимание, что мы используем набор данных для обучения и тестирования изображений кошек и собак по следующей ссылкеhttps://www.kaggle.com/c/dogs-vs-cats/data.

Импортируйте важные библиотеки и пакеты keras, как показано -

Следующий пакет, называемый последовательным, инициализирует нейронные сети как последовательные.

from keras.models import Sequential

Следующий пакет называется Conv2D используется для выполнения операции свертки, первого шага CNN.

from keras.layers import Conv2D

Следующий пакет называется MaxPoling2D используется для выполнения операции объединения, второго шага CNN.

from keras.layers import MaxPooling2D

Следующий пакет называется Flatten представляет собой процесс преобразования всех результирующих 2D-массивов в один длинный непрерывный линейный вектор.

from keras.layers import Flatten

Следующий пакет называется Dense используется для выполнения полного подключения нейронной сети, четвертого шага CNN.

from keras.layers import Dense

Теперь создайте объект последовательного класса.

S_classifier = Sequential()

Теперь следующий шаг - кодирование свертки.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

Вот relu функция выпрямителя.

Теперь следующим шагом CNN является операция объединения в результирующие карты признаков после части свертки.

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

Теперь преобразуйте все объединенные изображения в непрерывный вектор, используя льстивые -

S_classifier.add(Flatten())

Затем создайте полностью связанный слой.

S_classifier.add(Dense(units = 128, activation = 'relu'))

Здесь 128 - количество скрытых юнитов. Обычно количество скрытых единиц определяется как степень двойки.

Теперь инициализируйте выходной слой следующим образом -

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

Теперь скомпилируйте CNN, мы построили -

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

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

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

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

Теперь подгоните данные к модели, которую мы создали -

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

Здесь steps_per_epoch - количество обучающих образов.

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

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'