Почему Python лучше для AI? 2 часть

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

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

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

Контролируемое обучение может использоваться для решения двух типов задач машинного обучения:

регрессия
классификация

Для решения задач регрессии вы можете использовать известный алгоритм линейной регрессии.

Проблемы классификации могут быть решены с использованием следующих алгоритмов классификации:

Логистическая регрессия
Древо решений
Случайный Лес
Наивный байесовский классификатор
Метод опорных векторов
k-ближайших соседей

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

Вы можете пров

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

K означает алгоритм кластеризации | Алгоритмы машинного обучения | Edureka

Это видео поможет вам изучить концепции кластеризации K-Means и ее реализации с использованием Python.

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

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

Укрепление Учебное пособие | Пример обучения подкреплению с использованием Python | Edureka

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

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

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

В этом разделе мы реализуем машинное обучение с использованием Python. Итак, начнем.

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

Описание набора данных: Этот набор данных содержит около 145 тыс. Наблюдений за суточными погодными условиями, наблюдаемыми на многочисленных австралийских метеостанциях. Набор данных имеет около 24 функций, и мы будем использовать 23 функции (переменные Predictor), чтобы предсказать целевую переменную, а именно, «Дождь завтра».

Эта целевая переменная (RainT Saturday) будет хранить два значения:

Да: означает, что завтра будет дождь
Нет: обозначает, что завтра не будет дождя

Следовательно, это явно проблема классификации. Модель машинного обучения классифицирует результаты на 2 класса: ДА или НЕТ.

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

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

Шаг 1: Импортируйте необходимые библиотеки

# For linear algebra
import numpy as np
# For data processing
import pandas as pd

Шаг 2: Загрузите набор данных

#Load the data set
df = pd.read_csv('. . . Desktop/weatherAUS.csv')
#Display the shape of the data set
print('Size of weather data frame is :',df.shape)
#Display data
print(df[0:5])
 
Size of weather data frame is : (145460, 24)
        Date         Location   MinTemp ... RainToday  RISK_MM  RainTomorrow
0   2008-12-01   Albury           13.4 ...         No             0.0                   No
1   2008-12-02   Albury            7.4 ...          No             0.0                   No
2   2008-12-03   Albury          12.9 ...          No             0.0                   No
3   2008-12-04   Albury            9.2 ...          No             1.0                   No
4   2008-12-05   Albury          17.5 ...          No             0.2                   No

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

# Checking for null values
print(df.count().sort_values())
 
[5 rows x 24 columns]
Sunshine 75625
Evaporation 82670
Cloud3pm 86102
Cloud9am 89572
Pressure9am 130395
Pressure3pm 130432
WindDir9am 134894
WindGustDir 135134
WindGustSpeed 135197
Humidity3pm 140953
WindDir3pm 141232
Temp3pm 141851
RISK_MM 142193
RainTomorrow 142193
RainToday 142199
Rainfall 142199
WindSpeed3pm 142398
Humidity9am 142806
Temp9am 143693
WindSpeed9am 143693
MinTemp 143975
MaxTemp 144199
Location 145460
Date 145460
dtype: int64

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

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

Мы также удалим переменную ‘RISK_MM’, потому что мы хотим предсказать ‘RainTestival’, а RISK_MM (количество осадков на следующий день) может привести к утечке некоторой информации в нашу модель.

df = df.drop(columns=['Sunshine','Evaporation','Cloud3pm','Cloud9am','Location','RISK_MM','Date'],axis=1)
print(df.shape)
 
(145460, 17)

Далее мы удалим все нулевые значения в нашем фрейме данных.

#Removing null values
df = df.dropna(how='any')
print(df.shape)
 
(112925, 17)

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

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

from scipy import stats
z = np.abs(stats.zscore(df._get_numeric_data()))
print(z)
df= df[(z < 3).all(axis=1)]
print(df.shape)
 
[[0.11756741 0.10822071 0.20666127 ... 1.14245477 0.08843526 0.04787026]
[0.84180219 0.20684494 0.27640495 ... 1.04184813 0.04122846 0.31776848]
[0.03761995 0.29277194 0.27640495 ... 0.91249673 0.55672435 0.15688743]
...
[1.44940294 0.23548728 0.27640495 ... 0.58223051 1.03257127 0.34701958]
[1.16159206 0.46462594 0.27640495 ... 0.25166583 0.78080166 0.58102838]
[0.77784422 0.4789471 0.27640495 ... 0.2085487 0.37167606 0.56640283]]
(107868, 17)

Далее мы будем присваивать «0» и «1» вместо «ДА» и «НЕТ».

#Change yes and no to 1 and 0 respectvely for RainToday and RainTomorrow variable
df['RainToday'].replace({'No': 0, 'Yes': 1},inplace = True)
df['RainTomorrow'].replace({'No': 0, 'Yes': 1},inplace = True)

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

from sklearn import preprocessing
scaler = preprocessing.MinMaxScaler()
scaler.fit(df)
df = pd.DataFrame(scaler.transform(df), index=df.index, columns=df.columns)
df.iloc[4:10]
 
MinTemp  MaxTemp  Rainfall  ...  WindDir9am_W  WindDir9am_WNW  WindDir9am_WSW
4   0.628342  0.696296    0.035714 ...         0.0                 0.0                                        0.0
5   0.550802  0.632099    0.007143 ...         1.0                 0.0                                        0.0
6   0.542781  0.516049    0.000000 ...         0.0                 0.0                                        0.0
7   0.366310  0.558025    0.000000 ...         0.0                 0.0                                        0.0
8   0.419786  0.686420    0.000000 ...         0.0                 0.0                                        0.0
9   0.510695  0.641975    0.050000 ...         0.0                 0.0                                        0.0
 
[6 rows x 62 columns]

Шаг 4: Исследовательский анализ данных (EDA)

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

#Using SelectKBest to get the top features!
from sklearn.feature_selection import SelectKBest, chi2
X = df.loc[:,df.columns!='RainTomorrow']
y = df[['RainTomorrow']]
selector = SelectKBest(chi2, k=3)
selector.fit(X, y)
X_new = selector.transform(X)
print(X.columns[selector.get_support(indices=True)])
 
Index(['Rainfall', 'Humidity3pm', 'RainToday'], dtype='object')

Вывод дает нам три наиболее значимых предикторных переменных:

Rainfall
Humidity3pm
RainToday

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

#The important features are put in a data frame
df = df[['Humidity3pm','Rainfall','RainToday','RainTomorrow']]
 
#To simplify computations we will use only one feature (Humidity3pm) to build the model
 
X = df[['Humidity3pm']]
y = df[['RainTomorrow']]

В приведенном выше фрагменте кода «X» и «y» обозначают вход и выход соответственно.

Шаг 5: Построение модели машинного обучения

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

Мы будем строить классификационные модели, используя следующие алгоритмы:

Логистическая регрессия
Случайный Лес
Древо решений
Машина опорных векторов

Ниже приведен фрагмент кода для каждой из этих моделей классификации:

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

#Logistic Regression
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import time
 
#Calculating the accuracy and the time taken by the classifier
t0=time.time()
#Data Splicing
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25)
clf_logreg = LogisticRegression(random_state=0)
#Building the model using the training data set
clf_logreg.fit(X_train,y_train)
 
#Evaluating the model using testing data set
y_pred = clf_logreg.predict(X_test)
score = accuracy_score(y_test,y_pred)
 
#Printing the accuracy and the time taken by the classifier
print('Accuracy using Logistic Regression:',score)
print('Time taken using Logistic Regression:' , time.time()-t0)
 
Accuracy using Logistic Regression: 0.8330181332740015
Time taken using Logistic Regression: 0.1741015911102295

Random Forest Classifier

#Random Forest Classifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
 
#Calculating the accuracy and the time taken by the classifier
t0=time.time()
#Data Splicing
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=4,random_state=0)
#Building the model using the training data set
clf_rf.fit(X_train,y_train)
 
#Evaluating the model using testing data set
y_pred = clf_rf.predict(X_test)
score = accuracy_score(y_test,y_pred)
 
#Printing the accuracy and the time taken by the classifier
print('Accuracy using Random Forest Classifier:',score)
print('Time taken using Random Forest Classifier:' , time.time()-t0)
 
Accuracy using Random Forest Classifier: 0.8358363926280269
Time taken using Random Forest Classifier: 3.7179694175720215

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

#Decision Tree Classifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
 
#Calculating the accuracy and the time taken by the classifier
t0=time.time()
#Data Splicing
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25)
clf_dt = DecisionTreeClassifier(random_state=0)
#Building the model using the training data set
clf_dt.fit(X_train,y_train)
 
#Evaluating the model using testing data set
y_pred = clf_dt.predict(X_test)
score = accuracy_score(y_test,y_pred)
 
#Printing the accuracy and the time taken by the classifier
print('Accuracy using Decision Tree Classifier:',score)
print('Time taken using Decision Tree Classifier:' , time.time()-t0)
 
Accuracy using Decision Tree Classifier: 0.831423591797382
Time taken using Decision Tree Classifier: 0.0849456787109375

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

#Support Vector Machine
from sklearn import svm
from sklearn.model_selection import train_test_split
 
#Calculating the accuracy and the time taken by the classifier
t0=time.time()
#Data Splicing
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25)
clf_svc = svm.SVC(kernel='linear')
 
#Building the model using the training data set
clf_svc.fit(X_train,y_train)
 
#Evaluating the model using testing data set
y_pred = clf_svc.predict(X_test)
score = accuracy_score(y_test,y_pred)
 
#Printing the accuracy and the time taken by the classifier
print('Accuracy using Support Vector Machine:',score)
print('Time taken using Support Vector Machine:' , time.time()-t0)
 
Accuracy using Support Vector Machine: 0.7886676308080246
Time taken using Support Vector Machine: 88.42247271537781

Все модели классификации дают нам оценку точности приблизительно 83-84%, за исключением машин опорных векторов. Учитывая размер нашего набора данных, точность довольно хорошая.

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

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

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

Ограничения машинного обучения

Ниже приведены ограничения машинного обучения:

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

Вышеуказанные ограничения могут быть устранены с помощью Deep Learning.

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

Теперь давайте разберемся, как работает Deep Learning.

Как работает глубокое обучение?

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

Глубокое обучение основано на функциональности биологического нейрона, поэтому давайте разберемся, как мы подражаем этой функциональности в искусственном нейроне (также известном как перцептрон):

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

Теперь давайте разберемся, что же такое Deep Learning.

Что такое глубокое обучение?

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

на концепции искусственных нейронных сетей».

Глубокая нейронная сеть состоит из следующих слоев:

Входной слой
Скрытый слой
Выходной слой

На приведенном выше рисунке

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

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

Случаи использования глубокого обучения

Подумайте, как PayPal использует Deep Learning для выявления возможных мошеннических действий. PayPal обработал более 235 миллиардов долларов в платежах от четырех миллиардов транзакций более чем 170 миллионов клиентов.

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

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

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

Менеджер по рискам мошенничества и специалист по данным в PayPal Ке Ван

Простая линейная модель способна потреблять около 20 переменных. Однако с технологией Deep Learning можно управлять тысячами точек данных.

«Разница велика – вы сможете анализировать гораздо больше информации и выявлять более сложные модели»

Ке Ван.

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

Чтобы лучше понять Deep Learning, давайте разберемся, как работает Perceptron.

Что такое перцептрон?

Перцептрон – это однослойная нейронная сеть, которая используется для классификации линейных данных. Перцептрон имеет 4 важных компонента:

Вход
Вес и уклон
Функция суммирования
Функция активации или преобразования

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

Входы (x), полученные от входного слоя, умножаются на присвоенные им веса w. Умноженные значения затем добавляются для формирования взвешенной суммы. Взвешенная сумма входов и их соответствующие веса затем применяются к соответствующей функции активации. Функция активации отображает вход на соответствующий выход.

Вес и уклон в глубоком обучении

Почему мы должны присваивать вес каждому входу?

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

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

Функция суммирования

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

Функция активации

Основная цель функций активации – отобразить взвешенную сумму на выход. Функции активации, такие как tanh, ReLU, sigmoid и т. д., Являются примерами функций преобразования.

Чтобы узнать больше о функциях Перцептронов, вы можете пройти посмотреть статью Deep Learning: Perceptron Learning Algorithm .

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

Почему используется многослойный персептрон?

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

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

Что такое многослойный персептрон?

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

Как работает многослойный персептрон?

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

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

Этот процесс обновления весов и обучения сетей известен как Backpropagation .

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

Продолжение: https://telegra.ph/Pochemu-Python-luchshe-dlya-AI-3-chast-02-16

Источник : https://vk.com/@python_django_programirovanie-rukovodstvo-po-iskusstvennomu-intellektu-s-python