AI с Python — учебник для начинающих

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

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

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

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

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

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

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

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

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

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

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

А я могу научить себя

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

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

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

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

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

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

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

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

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

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

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

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

Как рассказывает американский психолог развития Говард Гарднер, интеллект имеет многократное значение —

Sr.No	Интеллект и описание	пример
1	Лингвистический интеллект Способность говорить, распознавать и использовать механизмы фонологии (речевые звуки), синтаксиса (грамматика) и семантики (смысл).	Рассказчики, Ораторы
2	Музыкальный интеллект Способность создавать, общаться и понимать смыслы из звука, понимать высоту, ритм.	Музыканты, певцы, композиторы
3	Логико-математический интеллект Умение использовать и понимать отношения при отсутствии действия или предметов. Это также способность понимать сложные и абстрактные идеи.	Математики, ученые
4	Пространственный интеллект Способность воспринимать визуальную или пространственную информацию, изменять ее и заново создавать визуальные изображения без привязки к объектам, создавать трехмерные изображения, а также перемещать и вращать их.	Считыватели карт, Космонавты, Физики
5	Телесно-кинестетический интеллект Способность использовать весь или часть тела для решения проблем или создания модных продуктов, контроля над мелкими и грубыми моторными навыками и манипулирования объектами.	Игроки, Танцоры
6	Внутриличностный интеллект Способность различать собственные чувства, намерения и мотивации.	Гаутама Будда
7	Межличностный интеллект Способность распознавать и различать чувства, убеждения и намерения других людей.	Массовые коммуникаторы, интервьюеры

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

Способность говорить, распознавать и использовать механизмы фонологии (речевые звуки), синтаксиса (грамматика) и семантики (смысл).

Музыкальный интеллект

Способность создавать, общаться и понимать смыслы из звука, понимать высоту, ритм.

Логико-математический интеллект

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

Пространственный интеллект

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

Телесно-кинестетический интеллект

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

Внутриличностный интеллект

Способность различать собственные чувства, намерения и мотивации.

Межличностный интеллект

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

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

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

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

• аргументация
• Учусь
• Решение проблем
• восприятие
• Лингвистический интеллект

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

аргументация

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

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

Учимся — я

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

восприятие

Это процесс сбора, интерпретации, выбора и организации сенсорной информации.

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

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

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

Что участвует в искусственном интеллекте

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

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

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

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

логика

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

поиск

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

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

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

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

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

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

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

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

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

азартные игры

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

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

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

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

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

Vision Systems

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Агент и Окружающая среда

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

агент

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

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

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

• Программный агент закодировал битовые строки в качестве своих программ и действий.

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

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

Программный агент закодировал битовые строки в качестве своих программ и действий.

Среда

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

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

AI с Python — Начало работы

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

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

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

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

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

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

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

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

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

Открытый исходный код — Python — это язык программирования с открытым исходным кодом. Это делает его широко популярным в сообществе.

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

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

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

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

• Легко читаемый — код Python более четко определен и видим для глаз.

• Простота в обслуживании — исходный код Python довольно прост в обслуживании.

• Широкая стандартная библиотека — основная часть библиотеки Python очень портативна и кроссплатформенна, совместима с UNIX, Windows и Macintosh.

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

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

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

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

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

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

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

Легко читаемый — код Python более четко определен и видим для глаз.

Простота в обслуживании — исходный код Python довольно прост в обслуживании.

Широкая стандартная библиотека — основная часть библиотеки Python очень портативна и кроссплатформенна, совместима с UNIX, Windows и Macintosh.

Интерактивный режим — Python поддерживает интерактивный режим, который позволяет проводить интерактивное тестирование и отладку фрагментов кода.

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

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

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

Программирование GUI — Python поддерживает приложения GUI, которые можно создавать и переносить на многие системные вызовы, библиотеки и системы Windows, такие как Windows MFC, Macintosh и система X Window Unix.

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

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

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

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

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

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

• Поддерживает автоматическую сборку мусора.

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

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

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

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

Поддерживает автоматическую сборку мусора.

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

Установка Python

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

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

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

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

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

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

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

• Скачивайте и извлекайте файлы.

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

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

• делать

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

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

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

Скачивайте и извлекайте файлы.

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

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

делать

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

Это устанавливает Python в стандартном месте / usr / local / bin и его библиотеках в / usr / local / lib / pythonXX, где XX — версия Python.

Установка Windows

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

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

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

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

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

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

Перейдите по ссылке для установщика Windows python-XYZ .msi-файла, где 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 .

• В оболочке ш или кш

  Введите PATH = «$ PATH: / usr / local / bin / python» и нажмите Enter .

В оболочке csh

Введите setenv PATH «$ PATH: / usr / local / bin / python» и нажмите Enter .

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

Введите export ATH = «$ PATH: / usr / local / bin / python» и нажмите Enter .

В оболочке ш или кш

Введите PATH = «$ PATH: / usr / local / bin / python» и нажмите Enter .

Примечание — / usr / local / bin / python — это путь к каталогу Python.

Настройка пути в Windows

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

• В командной строке введите путь% path%; C: \ Python и нажмите Enter .

В командной строке введите путь% path%; C: \ Python и нажмите Enter .

Примечание. C: \ Python — это путь к каталогу Python.

Запуск Python

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

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

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

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

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

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

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

$python # Unix/Linux

или же

python% # Unix/Linux

или же

C:> python # Windows/DOS

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

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

-d

Это обеспечивает отладочный вывод.

-о

Он генерирует оптимизированный байт-код (в результате чего .pyo файлы).

-S

Не запускайте сайт импорта для поиска путей Python при запуске.

-v

Подробный вывод (подробная трассировка в операторах импорта).

-Икс

Отключает встроенные исключения на основе классов (просто используйте строки); устарел начиная с версии 1.6.

-c cmd

Запускает скрипт Python, отправленный в виде строки cmd.

файл

Запустите скрипт Python из указанного файла.

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

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

$python script.py # Unix/Linux

или же,

python% script.py # Unix/Linux

или же,

C:> python script.py # Windows/DOS

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

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

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

• Unix — IDLE — самая первая Unix IDE для Python.

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

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

Unix — IDLE — самая первая Unix IDE для Python.

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

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.

AI с Python — Машинное обучение

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

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

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

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

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

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

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

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

Y = f(x)

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

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

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

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

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

Регрессия — проблема называется проблемой регрессии, когда у нас есть вывод реальной стоимости, такой как «расстояние», «килограмм» и т. Д.

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

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

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

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

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

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

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

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

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

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

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

Укрепление алгоритмов машинного обучения

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В основном логистическая регрессия — это алгоритм классификации, который используется для оценки дискретных значений, таких как 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 нам нужно работать на стадии предварительной обработки, такой как удаление шума.

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

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

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

K-средства кластеризации

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

AI с Python — Подготовка данных

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

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

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

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

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

Выполните следующие шаги для предварительной обработки данных в Python —

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

import numpy as np
import sklearn.preprocessing

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

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

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

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

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

Шаг 2. Определение примеров данных. После импорта пакетов нам нужно определить некоторые примеры данных, чтобы мы могли применить методы предварительной обработки к этим данным. Теперь мы определим следующий пример данных —

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])

Шаг 3 — Применение метода предварительной обработки. На этом этапе нам необходимо применить любой из методов предварительной обработки.

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

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

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

бинаризации

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

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

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

Бинаризованные данные

[[ 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 мы можем выполнить масштабирование наших входных данных, то есть вектор признаков —

# Минимальное максимальное масштабирование

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)

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

Мин макс масштабированные данные

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

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

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

L1 нормализация

Это также упоминается как Наименее Абсолютные Отклонения . Этот тип нормализации изменяет значения так, что сумма абсолютных значений всегда равна 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 нормализация

Это также упоминается как наименьших квадратов . Этот тип нормализации изменяет значения так, что сумма квадратов всегда равна 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 —

Шаг 1 — Импорт полезных пакетов

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

import numpy as np
from sklearn import preprocessing

Шаг 2 — Определение образцов меток

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

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

Шаг 3 — Создание и обучение объекта кодировщика меток

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

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

Следующим будет вывод после запуска приведенного выше кода Python —

LabelEncoder()

Шаг 4 — Проверка производительности путем кодирования случайного упорядоченного списка

Этот шаг можно использовать для проверки производительности путем кодирования случайного упорядоченного списка. Следующий код 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]

Шаг 5 — Проверка производительности путем декодирования случайного набора чисел —

Этот шаг можно использовать для проверки производительности путем декодирования случайного набора чисел. Следующий код 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']

Помеченные v / s Немеченые данные

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

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

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

AI с Python — контролируемое обучение: классификация

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

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

Шаги для построения классификатора в Python

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

Шаг 1 — Импорт Scikit-Learn

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

Import Sklearn

Шаг 2 — Импорт набора данных Scikit-learn

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

from sklearn.datasets import load_breast_cancer

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

data = load_breast_cancer()

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

• Имена меток классификации (target_names)
• Фактические метки (цель)
• Имена атрибутов / функций (feature_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 — Оценка модели и ее точности

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

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 , мы можем выяснить точность нашей модели. Мы будем использовать функцию precision_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 и Bernoulli .

Для построения наивной модели байесовского классификатора машинного обучения нам нужно следующее & минус

Dataset

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

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

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

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

Для начала нам нужно установить модуль 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 , мы можем выяснить точность нашей модели. Мы будем использовать функцию precision_score () для определения точности. Рассмотрим следующую команду —

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

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

Это был классификатор машинного обучения, основанный на наивной модели Байса-Гаусса.

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

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

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

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

Dataset

Мы будем использовать набор данных 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’s Dot. Его можно установить с помощью менеджера пакетов или 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’] и создаст следующее дерево решений —

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

Случайный лесной классификатор

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

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

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 — для отрицательного.

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

• Истинные плюсы — TP — это случаи, когда фактический класс точки данных равнялся 1, а прогнозируемый — также 1.

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

• Ложные положительные значения — FP — это случаи, когда фактический класс точки данных был равен 0, а прогнозируемый также равен 1.

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

Истинные плюсы — TP — это случаи, когда фактический класс точки данных равнялся 1, а прогнозируемый — также 1.

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

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

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

точность

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

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

точность

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

$$Precision = \ frac {TP} {TP + FP}$$

Напомним или Чувствительность

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

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

специфичность

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

$$Specificity = \ frac {TN} {TN + FP}$$

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

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

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

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

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

Решение

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

Re-Sampling

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

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

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

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

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

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

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

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

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

• Случайная избыточная выборка — этот метод направлен на балансирование распределения классов путем увеличения числа экземпляров в классе меньшинства путем их репликации.

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

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

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

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

Техника ансамбля

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

AI с Python — контролируемое обучение: регрессия

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

Построение регрессоров в 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

AI с Python — логическое программирование

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

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

концепция

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

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

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

факты

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

правила

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

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

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 нам нужно установить следующие два пакета:

Kanren

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

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.

Мы решаем вопрос о том, кто владеет зеброй с помощью 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)])

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

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.

AI с Python — обучение без учителя: кластеризация

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

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

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

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

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

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

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

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

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

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

Шаг 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()

Алгоритм среднего смещения

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

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

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

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

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

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

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

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

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

С помощью следующего кода мы реализуем алгоритм кластеризации Mean Shift в 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()

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

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]. Ниже приводится анализ этой оценки —

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

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

• Оценка -1 — Отрицательная оценка означает, что выборки были назначены в неправильные кластеры.

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

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

Оценка -1 — Отрицательная оценка означает, что выборки были назначены в неправильные кластеры.

Расчет силуэта

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

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

$$силуэт счет = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)}$$

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

Чтобы найти оптимальное количество кластеров, нам нужно снова запустить алгоритм кластеризации, импортировав модуль метрик из пакета 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))

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

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

Нахождение ближайших соседей

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

Концепция нахождения ближайших соседей может быть определена как процесс нахождения ближайшей точки к точке входа из данного набора данных. Основное использование этого алгоритма 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')

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

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 Ближайшие соседи

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

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

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

Концепция классификатора КНН

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

пример

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

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

Здесь мы используем модуль 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)

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

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])

AI с Python — обработка естественного языка

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• Планирование текста — это включает в себя получение соответствующего контента из базы знаний.

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

• Реализация текста — это отображение плана предложения в структуру предложения.

Планирование текста — это включает в себя получение соответствующего контента из базы знаний.

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

Реализация текста — это отображение плана предложения в структуру предложения.

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

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

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

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

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

Предложение может быть проанализировано по-разному. Например, «Он поднял жука с красной шапочкой». — Он использовал шапку, чтобы поднять жука, или он поднял жука с красной шапочкой?

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

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

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

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

• Фонология — это систематическое изучение звука.

• Морфология — это изучение построения слов из примитивных значимых единиц.

• Морфема — это примитивная единица значения в языке.

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

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

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

• Дискурс. Он касается того, как непосредственно предшествующее предложение может повлиять на толкование следующего предложения.

• Мир знаний — включает в себя общие знания о мире.

Фонология — это систематическое изучение звука.

Морфология — это изучение построения слов из примитивных значимых единиц.

Морфема — это примитивная единица значения в языке.

Синтаксис — относится к упорядочению слов для составления предложения. Это также включает определение структурной роли слов в предложении и во фразе.

Семантика — это касается значения слов и того, как объединить слова в значимые фразы и предложения.

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

Дискурс. Он касается того, как непосредственно предшествующее предложение может повлиять на толкование следующего предложения.

Мир знаний — включает в себя общие знания о мире.

Шаги в НЛП

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

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

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

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

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

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

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

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

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

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

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

AI с Python — пакет NLTK

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

необходимое условие

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

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

Импорт НЛТК

Нам нужно установить 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

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

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

лексемизацию

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

Вход — Манго, банан, ананас и яблоко — все это фрукты.

Выход —

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

В модуле 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

Морфологический

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

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

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

PorterStemmer пакет

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

from nltk.stem.porter import PorterStemmer

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

LancasterStemmer пакет

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

from nltk.stem.lancaster import LancasterStemmer

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

SnowballStemmer пакет

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

from nltk.stem.snowball import SnowballStemmer

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

Все эти алгоритмы имеют разный уровень строгости. Если мы сравним эти три стеммера, то стеммеры Портера наименее строгие, а Ланкастер — самый строгий. Снежный комик хорош как по скорости, так и по строгости.

лемматизации

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

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

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

Пакет WordNetLemmatizer

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

from nltk.stem import WordNetLemmatizer

Чанкинг: деление данных на чанки

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

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

Типы чанкинга

Есть два типа чанкинга. Типы следующие:

Чанкинг

В этом процессе фрагментации объект, вещи и т. Д. Становятся более общими, а язык становится более абстрактным. Есть больше шансов на соглашение. В этом процессе мы уменьшаем масштаб. Например, если мы разберемся с вопросом, «для чего предназначены автомобили»? Мы можем получить ответ «транспорт».

Расщепление

В этом процессе фрагментации объект, вещи и т. Д. Движутся к тому, чтобы стать более специфичными, а язык становится более проницательным. Более глубокая структура будет рассмотрена при разбивке. В этом процессе мы увеличиваем масштаб. Например, если мы разберемся с вопросом «Расскажите конкретно об автомобиле»? Мы получим меньшие кусочки информации об автомобиле.

пример

В этом примере мы сделаем чанки Noun-Phrase, категорию чанков, которые найдут куски именных фраз в предложении, используя модуль NLTK в Python —

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

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

Шаг 2 — На этом шаге нам нужно создать парсер чанков. Было бы разобрать грамматику и дать вывод.

Шаг 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 строит модель, используя матрицу терминов документа. Как следует из названия, матрица терминов документа является матрицей различного количества слов, встречающихся в документе. С помощью этой матрицы текстовый документ может быть представлен в виде взвешенной комбинации различных слов. Устанавливая порог и выбирая слова, которые являются более значимыми, мы можем построить гистограмму всех слов в документах, которые можно использовать как вектор признаков. Ниже приведен пример, чтобы понять концепцию матрицы термина документа —

пример

Предположим, у нас есть следующие два предложения —

• Предложение 1 — Мы используем модель Bag of Words.

• Предложение 2 — модель Bag of Words используется для извлечения функций.

Предложение 1 — Мы используем модель Bag of Words.

Предложение 2 — модель Bag of Words используется для извлечения функций.

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

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

Теперь нам нужно построить гистограмму для каждого предложения, используя количество слов в каждом предложении —

• Предложение 1 — [1,1,1,1,1,1,1,1,0,0,0,0,0]

• Предложение 2 — [0,0,0,1,1,1,1,1,1,1,1,1,1]

Предложение 1 — [1,1,1,1,1,1,1,1,0,0,0,0,0]

Предложение 2 — [0,0,0,1,1,1,1,1,1,1,1,1,1]

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

Концепция статистики

Концепция статистики называется TermFrequency-Inverse Document Frequency (tf-idf). Каждое слово важно в документе. Статистика помогает нам понять важность каждого слова.

Термин частота (тс)

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

Частота обратных документов (IDF)

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

Построение модели мешка слов в НЛТК

В этом разделе мы определим коллекцию строк, используя 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

Пол Finder

В этом заявлении о проблемах классификатор будет обучен определению пола (мужского или женского пола) путем предоставления имён. Нам нужно использовать эвристику для построения вектора признаков и обучения классификатора. Мы будем использовать помеченные данные из пакета 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 (Singular Value Decomposition) в матрице терминов документа.

Неотрицательная матричная факторизация (НМФ)

Он также основан на линейной алгебре.

Все вышеупомянутые алгоритмы для моделирования тем будут иметь количество тем в качестве параметра, матрицу документа-слова в качестве входных данных и WTM (матрица тем Word) и TDM (матрица документов тем) в качестве выходных данных.

AI с Python — анализ данных временных рядов

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

Вступление

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

Основная концепция анализа последовательностей или анализа временных рядов

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

пример

Рассмотрим следующий пример, чтобы понять прогноз последовательности. Здесь A, B, C, D — заданные значения, и вы должны предсказать значение E, используя модель прогнозирования последовательности.

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

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

Панды

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

pip install pandas

Если вы используете Anaconda и хотите установить с помощью менеджера пакетов conda , вы можете использовать следующую команду:

conda install -c anaconda pandas

hmmlearn

Это 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

Панды: обработка, нарезка и извлечение статистики из данных временных рядов

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

• Создайте диапазон дат с помощью пакета pd.date_range

• Индекс панды с датами с помощью пакета pd.Series

• Выполните повторную выборку с помощью пакета ts.resample

• Изменить частоту

Создайте диапазон дат с помощью пакета 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

Получать все сразу

Если вы хотите рассчитать всю статистику за раз, вы можете использовать функцию description (), как показано здесь —

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

Повторные выборки

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

• Временной период
• метод

Повторная выборка со средним ()

Вы можете использовать следующий код для повторной выборки данных с помощью метода 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()

Затем вы можете наблюдать следующий график как результат повторной выборки с помощью медианы () —

Скользящее среднее

Вы можете использовать следующий код для расчета скользящего (скользящего) среднего значения —

timeseries.rolling(window = 12, center = False).mean().plot(style = '-g')
plt.show()

Затем вы можете наблюдать следующий график как результат скользящего (скользящего) среднего значения —

Анализ последовательных данных по скрытой марковской модели (HMM)

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

Скрытая Марковская Модель (HMM)

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

Математически HMM состоит из следующих переменных:

Штаты (S)

Это набор скрытых или скрытых состояний, присутствующих в HMM. Обозначается С.

Выходные символы (O)

Это набор возможных выходных символов, присутствующих в HMM. Обозначается О.

Матрица вероятности перехода состояния (A)

Это вероятность перехода из одного состояния в другое. Обозначается А.

Матрица вероятности выбросов наблюдений (B)

Это вероятность испускания / наблюдения символа в определенном состоянии. Обозначается Б.

Матрица априорной вероятности (Π)

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

Следовательно, НММ может быть определен как ? = (S, O, A, B, ?) ,

где,

• S = {s ₁ , s ₂ ,…, s _N } — это набор из N возможных состояний,
• O = {o ₁ , o ₂ ,…, o _M } представляет собой набор из M возможных символов наблюдения,
• A является матрицей вероятности перехода состояния N?N (TPM),
• B — N observationM матрица наблюдения или вероятности выбросов (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()

AI с Python — распознавание речи

В этой главе мы узнаем о распознавании речи с использованием AI с Python.

Речь — самое основное средство общения взрослого человека. Основная цель обработки речи — обеспечить взаимодействие человека и машины.

Система обработки речи имеет в основном три задачи —

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

• Во-вторых , обработка естественного языка, чтобы позволить машине понять, что мы говорим, и

• В-третьих , синтез речи, чтобы позволить машине говорить.

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

Во-вторых , обработка естественного языка, чтобы позволить машине понять, что мы говорим, и

В-третьих , синтез речи, чтобы позволить машине говорить.

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

Создание распознавателя речи

Распознавание речи или автоматическое распознавание речи (ASR) является центром внимания для проектов ИИ, таких как робототехника. Без ASR невозможно представить когнитивного робота, взаимодействующего с человеком. Однако не всегда легко создать распознаватель речи.

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

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

• Размер словарного запаса — размер словарного запаса влияет на легкость разработки ASR. Рассмотрим следующие размеры словарного запаса для лучшего понимания.

• Небольшой словарный запас состоит из 2-100 слов, например, как в системе голосового меню

• Лексика среднего размера состоит, например, из нескольких сотен-тысяч слов, как в задаче поиска в базе данных.

• Большой словарный запас состоит из нескольких тысяч слов, как в общей задаче диктовки.

Обратите внимание: чем больше размер словарного запаса, тем сложнее выполнить распознавание.

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

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

• Стиль речи — прочитанная речь может быть в формальном стиле или спонтанной и разговорной со случайным стилем. Последнее сложнее распознать.

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

• Тип шума — Шум является еще одним фактором, который следует учитывать при разработке ASR. Отношение сигнал / шум может быть в различных диапазонах, в зависимости от акустической среды, которая наблюдает меньше, чем фоновый шум —

• Если отношение сигнал / шум превышает 30 дБ, оно считается высоким диапазоном

• Если отношение сигнал / шум находится между 30 дБ и 10 дБ, оно считается средним SNR

• Если отношение сигнал / шум меньше 10 дБ, оно считается низким диапазоном

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

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

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

Небольшой словарный запас состоит из 2-100 слов, например, как в системе голосового меню

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

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

Обратите внимание: чем больше размер словарного запаса, тем сложнее выполнить распознавание.

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

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

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

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

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

Если отношение сигнал / шум превышает 30 дБ, оно считается высоким диапазоном

Если отношение сигнал / шум находится между 30 дБ и 10 дБ, оно считается средним SNR

Если отношение сигнал / шум меньше 10 дБ, оно считается низким диапазоном

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

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

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

Вы должны будете выполнить шаги, описанные ниже, чтобы создать распознаватель речи —

Визуализация аудиосигналов — чтение из файла и работа с ним

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

запись

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

отбор проб

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

пример

В следующем примере показан пошаговый подход к анализу аудиосигнала с использованием 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 .

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)

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

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 с Python — эвристический поиск

Эвристический поиск играет ключевую роль в искусственном интеллекте. В этой главе вы узнаете подробно об этом.

Концепция эвристического поиска в AI

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

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

Разница между неинформированным и информированным поиском

Существует два типа стратегий управления или методов поиска: неосведомленные и информированные. Они подробно объяснены как дано здесь —

Неинформированный поиск

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

Информированный поиск

Это также называется эвристическим поиском или эвристической стратегией управления. Он назван так, потому что есть некоторая дополнительная информация о штатах. Эта дополнительная информация полезна для вычисления предпочтения дочерних узлов для изучения и расширения. Там будет эвристическая функция, связанная с каждым узлом. Best First Search (BFS), A *, Mean и Analysis являются примерами информированного поиска.

Проблемы удовлетворения ограничений (ПСУ)

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

Проблема реального мира, решаемая удовлетворением ограничений

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

Решение алгебраических отношений

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

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

Обратите внимание, что перед написанием программы нам нужно установить пакет Python с именем python-constraint. Вы можете установить его с помощью следующей команды —

pip install python-constraint

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

Импортируйте пакет ограничений с помощью следующей команды —

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 .

AI с Python — Игры

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

Алгоритмы поиска

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

Как это устроено

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

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

Комбинационный поиск

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

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

Минимаксный алгоритм

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

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

Альфа-бета-обрезка

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

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

Алгоритм Негамакс

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

Создание ботов для игр

Чтобы собрать ботов для игры двух игроков в 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 .

AI с Python — Нейронные сети

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

Что такое искусственные нейронные сети (ANN)

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

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

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

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

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

pip install NeuroLab

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

conda install -c labfabulous neurolab

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

В этом разделе давайте построим некоторые нейронные сети на Python с помощью пакета NeuroLab.

Классификатор на основе перцептрона

Перцептроны являются строительными блоками ANN. Если вы хотите узнать больше о Перцептроне, вы можете перейти по ссылке — искусственная_неуральная_сеть

Ниже приведено пошаговое выполнение кода 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)

Теперь тренируйте сеть. Здесь мы используем правило Delta для обучения.

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')

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

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()

В результате вышеприведенных команд вы можете наблюдать графики, как показано ниже —

AI с Python — обучение усилению

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

Основы обучения армированию

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

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

Строительные блоки: окружающая среда и агент

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

агент

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

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

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

• Программный агент закодировал битовые строки в качестве своих программ и действий.

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

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

Программный агент закодировал битовые строки в качестве своих программ и действий.

Терминология агентов

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

• Показатель эффективности агента — это критерий, который определяет, насколько успешным является агент.

• Поведение агента — это действие, которое агент выполняет после любой заданной последовательности восприятий.

• Percept — это перцептивные данные агента в данном случае.

• Последовательность восприятия — это история всего, что агент воспринял до настоящего времени.

• Функция агента — это карта от последовательности предписаний к действию.

Показатель эффективности агента — это критерий, который определяет, насколько успешным является агент.

Поведение агента — это действие, которое агент выполняет после любой заданной последовательности восприятий.

Percept — это перцептивные данные агента в данном случае.

Последовательность восприятия — это история всего, что агент воспринял до настоящего времени.

Функция агента — это карта от последовательности предписаний к действию.

Среда

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

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

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

Свойства окружающей среды

Среда обладает множественными свойствами, как описано ниже —

• Дискретный / Непрерывный — Если существует ограниченное количество четко определенных состояний среды, среда является дискретной, в противном случае она является непрерывной. Например, шахматы — это дискретная среда, а вождение — это непрерывная среда.

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

• Статический / Динамический — если среда не изменяется во время действия агента, то она является статической; в противном случае это динамично.

• Один агент / Несколько агентов — Среда может содержать другие агенты, которые могут быть того же или другого типа, что и агент.

• Доступный / недоступный — если сенсорный аппарат агента может иметь доступ к полному состоянию среды, то среда доступна этому агенту; в противном случае он недоступен.

• Детерминированный / недетерминированный — если следующее состояние среды полностью определяется текущим состоянием и действиями агента, то среда является детерминированной; в противном случае это недетерминированный.

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

Дискретный / Непрерывный — Если существует ограниченное количество четко определенных состояний среды, среда является дискретной, в противном случае она является непрерывной. Например, шахматы — это дискретная среда, а вождение — это непрерывная среда.

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

Статический / Динамический — если среда не изменяется во время действия агента, то она является статической; в противном случае это динамично.

Один агент / Несколько агентов — Среда может содержать другие агенты, которые могут быть того же или другого типа, что и агент.

Доступный / недоступный — если сенсорный аппарат агента может иметь доступ к полному состоянию среды, то среда доступна этому агенту; в противном случае он недоступен.

Детерминированный / недетерминированный — если следующее состояние среды полностью определяется текущим состоянием и действиями агента, то среда является детерминированной; в противном случае это недетерминированный.

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

Построение среды с помощью 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

Обратите внимание, что тележка может уравновеситься.

AI с Python — генетические алгоритмы

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

Что такое генетические алгоритмы?

Генетические алгоритмы (GA) — это алгоритмы поиска, основанные на понятиях естественного отбора и генетики. GA — это подмножество гораздо большей ветви вычислений, известной как эволюционные вычисления.

GA были разработаны Джоном Холландом и его студентами и коллегами из Мичиганского университета, прежде всего Дэвидом Э. Голдбергом. С тех пор он был опробован на различных задачах оптимизации с высокой степенью успеха.

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

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

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

Как использовать GA для задач оптимизации?

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

Этапы механизма GA для процесса оптимизации

Ниже приведена последовательность шагов механизма GA при использовании для оптимизации задач.

• Шаг 1 — Генерация начальной популяции случайным образом.

• Шаг 2 — Выберите исходное решение с наилучшими значениями пригодности.

• Шаг 3 — рекомбинируйте выбранные решения, используя операторы мутации и кроссовера.

• Шаг 4 — Вставьте потомство в популяцию.

• Шаг 5 — Теперь, если условие остановки выполнено, верните решение с наилучшим значением пригодности. Остальное перейдите к шагу 2.

Шаг 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 поколений.

AI с Python — компьютерное видение

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

Компьютерное зрение

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

Иерархия компьютерного зрения

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

• Низкоуровневое зрение — включает изображение процесса для извлечения объектов.

• Видение промежуточного уровня — включает распознавание объектов и интерпретацию трехмерных сцен

• Видение высокого уровня — включает концептуальное описание сцены, такой как активность, намерение и поведение.

Низкоуровневое зрение — включает изображение процесса для извлечения объектов.

Видение промежуточного уровня — включает распознавание объектов и интерпретацию трехмерных сцен

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

Computer Vision Vs Обработка изображений

Обработка изображений изучает преобразование изображения в изображение. Вход и выход обработки изображения оба изображения.

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

Приложения

Компьютерное зрение находит применение в следующих областях —

робототехника

• Локализация — определить местоположение робота автоматически

• навигация

• Избегание препятствий

• Сборка (колышек, сварка, покраска)

• Манипуляции (например, робот-манипулятор PUMA)

• Human Robot Interaction (HRI): интеллектуальная робототехника для взаимодействия и обслуживания людей

Локализация — определить местоположение робота автоматически

навигация

Избегание препятствий

Сборка (колышек, сварка, покраска)

Манипуляции (например, робот-манипулятор PUMA)

Human Robot Interaction (HRI): интеллектуальная робототехника для взаимодействия и обслуживания людей

Лекарственное средство

• Классификация и обнаружение (например, классификация повреждения или клеток и обнаружение опухоли)

• 2D / 3D сегментация

• 3D реконструкция человеческого органа (МРТ или УЗИ)

• Визуальная робототехника

Классификация и обнаружение (например, классификация повреждения или клеток и обнаружение опухоли)

2D / 3D сегментация

3D реконструкция человеческого органа (МРТ или УЗИ)

Визуальная робототехника

Безопасность

• Биометрия (радужная оболочка, отпечаток пальца, распознавание лица)
• Наблюдение — обнаружение определенных подозрительных действий или поведения

Транспорт

• Автономное транспортное средство
• Безопасность, например, мониторинг бдительности водителя

Применение промышленной автоматизации

• Промышленный контроль (обнаружение дефектов)
• сборочный
• Считывание штрих-кода и этикетки на упаковке
• Сортировка объектов
• Понимание документа (например, OCR)

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

Для компьютерного зрения с Python вы можете использовать популярную библиотеку OpenCV (Open Source Computer Vision). Это библиотека функций программирования, в основном предназначенная для компьютерного зрения в реальном времени. Он написан на 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 () — это функция для чтения изображения. OpenCV imread () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

• Функция imshow () — это функция для отображения изображения в окне. Окно автоматически подгоняется под размер изображения. OpenCV imshow () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

• Функция imwrite () — это функция для записи изображения. OpenCV imwrite () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

Функция imread () — это функция для чтения изображения. OpenCV imread () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

Функция imshow () — это функция для отображения изображения в окне. Окно автоматически подгоняется под размер изображения. OpenCV imshow () поддерживает различные форматы изображений, такие как PNG, JPEG, JPG, TIFF и т. Д.

Функция imwrite () — это функция для записи изображения. 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 создаст изображение с именемdge_penguins.jpg с обнаружением краев.

Обнаружение Лица

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

Данные каскада Хаара

Нам нужны данные, чтобы использовать каскадный классификатор Хаара. Вы можете найти эти данные в нашем пакете OpenCV. После установки OpenCv вы можете увидеть имя папки haarcascades . Там были бы .xml файлы для другого приложения. Теперь скопируйте их все для различного использования и вставьте в новую папку в текущем проекте.

пример

Ниже приведен код 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 имеет встроенное средство для обнаружения глаз. Мы собираемся использовать каскадный классификатор Хаара для обнаружения глаз.

пример

В следующем примере приведен код 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 с обнаружением глаз, как показано на рисунке —

AI с Python — глубокое обучение

Искусственная нейронная сеть (ANN) — это эффективная вычислительная система, центральная тема которой заимствована из аналогии биологических нейронных сетей. Нейронные сети являются одним из типов моделей для машинного обучения. В середине 1980-х и начале 1990-х годов в нейронных сетях был сделан значительный архитектурный прогресс. В этой главе вы узнаете больше о Deep Learning, подходе AI.

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

Машинное обучение v / s Deep Learning

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

Зависимость данных

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

Зависимость от машины

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

Функция извлечения

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

Время исполнения

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

Подход к решению проблем

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

Сверточная нейронная сеть (CNN)

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

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

Обзор архитектуры CNN

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

Архитектура CNNs имеет нейроны, расположенные в 3 измерениях, называемых шириной, высотой и глубиной. Каждый нейрон в текущем слое связан с небольшим участком выхода предыдущего слоя. Это похоже на наложение фильтра ? × ? на входное изображение. Он использует М- фильтры, чтобы быть уверенным в получении всех деталей. Эти М- фильтры являются экстракторами объектов, которые извлекают такие элементы, как края, углы и т. Д.

Слои, используемые для построения CNN

Следующие слои используются для построения CNN —

• Входной слой — принимает исходные данные изображения как есть.

• Сверточный слой — этот слой является основным строительным блоком CNN, который выполняет большинство вычислений. Этот слой вычисляет свертки между нейронами и различными участками на входе.

• Recified Linear Unit Layer — Применяет функцию активации к выходу предыдущего слоя. Он добавляет нелинейность в сеть, так что он может хорошо обобщать функции любого типа.

• Уровень объединения — Объединение помогает нам сохранять только важные части по мере продвижения в сети. Слой пула работает независимо на каждом срезе глубины ввода и пространственно изменяет его размер. Он использует функцию MAX.

• Fully Connected layer / Output layer — этот слой вычисляет выходные баллы в последнем слое. Полученный результат имеет размер ? × ? × ? , где L — число классов обучающих наборов данных.

Входной слой — принимает исходные данные изображения как есть.

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

Recified Linear Unit 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

Построение линейного регрессора с использованием ANN

В этом разделе вы узнаете, как построить линейный регрессор, используя искусственные нейронные сети. Вы можете использовать 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 представляет собой процесс преобразования всех результирующих двумерных массивов в один длинный непрерывный линейный вектор.

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 — количество скрытых юнитов. Обычной практикой является определение количества скрытых единиц как степени 2.

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

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 имеет количество тренировочных образов.

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