Почему Python лучше для AI? 3 часть
Глубокое обучение с Python
Чтобы подвести итог, как работает Deep Learning, давайте рассмотрим реализацию Deep Learning с Python.
Постановка задачи: изучить набор данных банковского кредита и определить, является ли транзакция мошеннической или нет на основании прошлых данных.
Описание набора данных: набор данных описывает транзакции, совершенные европейскими держателями карт в 2013 году. Он содержит подробности транзакций за два дня, когда из 284 807 транзакций было совершено 492 мошеннических действия.
Логика: для построения нейронной сети, которая может классифицировать транзакцию как мошенническую или не основанную на прошлых транзакциях.
Теперь, когда вы знаете цель этой демонстрации, давайте приступим к демонстрации.
Шаг 1: Импортируйте необходимые пакеты
#Import requires packages import numpy as np import pandas as pd import os os.environ["TF_CPP_MIN_LOG_LEVEL"]="3" from sklearn.utils import shuffle import matplotlib.pyplot as plt # Import Keras, Dense, Dropout from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout import matplotlib.pyplot as plt import seaborn as sns from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score , fbeta_score, classification_report, confusion_matrix, precision_recall_curve, roc_auc_score , roc_curve
Шаг 2: Загрузите набор данных
# Import the dataset
df_full = pd.read_csv('C://Users//NeelTemp//Desktop//ai with python//creditcard.csv')
# Print out first 5 row of the data set
print(df_full.head(5))
Time V1 V2 V3 ... V27 V28 Amount Class
0 0.0 -1.359807 -0.072781 2.536347 ... 0.133558 -0.021053 149.62 0
1 0.0 1.191857 0.266151 0.166480 ... -0.008983 0.014724 2.69 0
2 1.0 -1.358354 -1.340163 1.773209 ... -0.055353 -0.059752 378.66 0
3 1.0 -0.966272 -0.185226 1.792993 ... 0.062723 0.061458 123.50 0
4 2.0 -1.158233 0.877737 1.548718 ... 0.219422 0.215153 69.99 0
IВ приведенном выше описании целевой переменной является переменная «Class». Может содержать два значения:
- Class 0: обозначает, что транзакция не является мошеннической
- Class 1: обозначает, что транзакция является мошеннической
Остальные переменные являются переменными предикторами, которые помогут нам понять, является ли транзакция мошеннической или нет.
# Count the number of samples for each class (Class 0 and Class 1) print(df_full.Class.value_counts()) 0 284315 1 492 Name: Class, dtype: int64
Приведенный выше вывод показывает, что у нас около 284 тыс не мошеннических транзакций и «492» мошеннических транзакций. Разница между этими двумя классами огромна, и это делает наш набор данных очень несбалансированным. Поэтому мы должны выбрать наш набор данных таким образом, чтобы количество мошеннических и не мошеннических транзакций было сбалансированным.
Для этого мы можем использовать метод статистической выборки, называемый стратифицированной выборкой .
Шаг 3: Подготовка данных
#Sort the dataset by "class" to apply stratified sampling df_full.sort_values(by='Class', ascending=False, inplace=True)
Далее мы удалим столбец времени, поскольку он не нужен для прогнозирования выходных данных.
# Remove the "Time" coloumn
df_full.drop('Time', axis=1, inplace=True)
# Create a new data frame with the first "3000" samples
df_sample = df_full.iloc[:3000, :]
# Now count the number of samples for each class
print(df_sample.Class.value_counts())
0 2508
1 492
Name: Class, dtype: int64
Наш набор данных выглядит хорошо сбалансированным.
#Randomly shuffle the data set shuffle_df = shuffle(df_sample, random_state=42)
Шаг 4: Сплайсинг данных
Сплайсинг данных – это процесс разделения набора данных на данные обучения и тестирования.
# Spilt the dataset into train and test data frame df_train = shuffle_df[0:2400] df_test = shuffle_df[2400:] # Spilt each dataframe into feature and label train_feature = np.array(df_train.values[:, 0:29]) train_label = np.array(df_train.values[:, -1]) test_feature = np.array(df_test.values[:, 0:29]) test_label = np.array(df_test.values[:, -1]) # Display the size of the train dataframe print(train_feature.shape) (2400, 29) # Display the size of test dataframe print(train_label.shape) (2400,)
Шаг 5: Нормализация данных
# Standardize the features coloumns to increase the training speed
scaler = MinMaxScaler()
scaler.fit(train_feature)
train_feature_trans = scaler.transform(train_feature)
test_feature_trans = scaler.transform(test_feature)
# A function to plot the learning curves
def show_train_history(train_history, train, validation):
plt.plot(train_history.history[train])
plt.plot(train_history.history[validation])
plt.title('Train History')
plt.ylabel(train)
plt.xlabel('Epoch')
plt.legend(['train', 'validation'], loc='best')
plt.show()
Шаг 6: Построение нейронной сети
В этой демонстрации мы создадим нейронную сеть, содержащую 3 полностью связанных слоя с Dropout. Первый и второй уровни имеют 200 нейронных блоков с ReLU в качестве функции активации, а третий уровень, то есть выходной слой, имеет один нейронный блок.
Для построения нейронной сети мы будем использовать пакет Keras, который мы обсуждали ранее. Тип модели будет последовательным, что является самым простым способом построения модели в Керасе. В последовательной модели каждому слою присваиваются веса таким образом, что веса в следующем слое соответствуют предыдущему слою.
#Select model type model = Sequential()
Далее мы будем использовать функцию add() для добавления плотных слоев. «Плотный»(Dense) – это самый базовый тип слоя, который подходит для большинства случаев. Все узлы в плотном слое спроектированы так, что узлы в предыдущем слое соединяются с узлами в текущем слое.
# Adding a Dense layer with 200 neuron units and ReLu activation function model.add(Dense(units=200, input_dim=29, kernel_initializer='uniform', activation='relu')) # Add Dropout model.add(Dropout(0.5))
Выпадение(Dropout) – это метод регуляризации, используемый для избежания перегрузки в нейронной сети. В этой технике, где случайно выбранные нейроны сбрасываются во время тренировки.
# Second Dense layer with 200 neuron units and ReLu activation function model.add(Dense(units=200, kernel_initializer='uniform', activation='relu')) # Add Dropout model.add(Dropout(0.5)) # The output layer with 1 neuron unit and Sigmoid activation function model.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) # Display the model summary print(model.summary()) Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) (None, 200) 6000 _________________________________________________________________ dropout_1 (Dropout) (None, 200) 0 _________________________________________________________________ dense_2 (Dense) (None, 200) 40200 _________________________________________________________________ dropout_2 (Dropout) (None, 200) 0 _________________________________________________________________ dense_3 (Dense) (None, 1) 201 ================================================================= Total params: 46,401 Trainable params: 46,401 Non-trainable params: 0
Для оптимизации мы будем использовать оптимизатор Adam (встроенный в Keras). Оптимизаторы используются для обновления значений веса и параметров байса во время тренировки модели.
# Using 'Adam' to optimize the Accuracy matrix model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Fit the model # number of epochs = 200 and batch size = 500 train_history = model.fit(x=train_feature_trans, y=train_label, validation_split=0.8, epochs=200, batch_size=500, verbose=2) Train on 479 samples, validate on 1921 samples Epoch 1/200 - 1s - loss: 0.6916 - acc: 0.5908 - val_loss: 0.6825 - val_acc: 0.8360 Epoch 2/200 - 0s - loss: 0.6837 - acc: 0.7933 - val_loss: 0.6717 - val_acc: 0.8360 Epoch 3/200 - 0s - loss: 0.6746 - acc: 0.7996 - val_loss: 0.6576 - val_acc: 0.8360 Epoch 4/200 - 0s - loss: 0.6628 - acc: 0.7996 - val_loss: 0.6419 - val_acc: 0.8360 Epoch 5/200 - 0s - loss: 0.6459 - acc: 0.7996 - val_loss: 0.6248 - val_acc: 0.8360 # Display the accuracy curves for training and validation sets show_train_history(train_history, 'acc', 'val_acc')
# Display the loss curves for training and validation sets show_train_history(train_history, 'loss', 'val_loss')
Шаг 7: Оценка модели
# Testing set for model evaluation
scores = model.evaluate(test_feature_trans, test_label)
# Display accuracy of the model
print('n')
print('Accuracy=', scores[1])
Accuracy= 0.98
prediction = model.predict_classes(test_feature_trans)
df_ans = pd.DataFrame({'Real Class': test_label})
df_ans['Prediction'] = prediction
df_ans['Prediction'].value_counts()
df_ans['Real Class'].value_counts()
cols = ['Real_Class_1', 'Real_Class_0'] # Gold standard
rows = ['Prediction_1', 'Prediction_0'] # Diagnostic tool (our prediction)
B1P1 = len(df_ans[(df_ans['Prediction'] == df_ans['Real Class']) & (df_ans['Real Class'] == 1)])
B1P0 = len(df_ans[(df_ans['Prediction'] != df_ans['Real Class']) & (df_ans['Real Class'] == 1)])
B0P1 = len(df_ans[(df_ans['Prediction'] != df_ans['Real Class']) & (df_ans['Real Class'] == 0)])
B0P0 = len(df_ans[(df_ans['Prediction'] == df_ans['Real Class']) & (df_ans['Real Class'] == 0)])
conf = np.array([[B1P1, B0P1], [B1P0, B0P0]])
df_cm = pd.DataFrame(conf, columns=[i for i in cols], index=[i for i in rows])
f, ax = plt.subplots(figsize=(5, 5))
sns.heatmap(df_cm, annot=True, ax=ax, fmt='d')
plt.show()
# Making x label be on top is common in textbooks.
ax.xaxis.set_ticks_position('top')
print('Total number of test cases: ', np.sum(conf))
Total number of test cases: 600
# Model summary function
def model_efficacy(conf):
total_num = np.sum(conf)
sen = conf[0][0] / (conf[0][0] + conf[1][0])
spe = conf[1][1] / (conf[1][0] + conf[1][1])
false_positive_rate = conf[0][1] / (conf[0][1] + conf[1][1])
false_negative_rate = conf[1][0] / (conf[0][0] + conf[1][0])
print('Total number of test cases: ', total_num)
Total number of test cases: 600
print('G = gold standard, P = prediction')
# G = gold standard; P = prediction
print('G1P1: ', conf[0][0])
print('G0P1: ', conf[0][1])
print('G1P0: ', conf[1][0])
print('G0P0: ', conf[1][1])
print('--------------------------------------------------')
print('Sensitivity: ', sen)
print('Specificity: ', spe)
print('False_positive_rate: ', false_positive_rate)
print('False_negative_rate: ', false_negative_rate)
Вывод:
G = gold standard, P = prediction G1P1: 74 G0P1: 5 G1P0: 7 G0P0: 514 -------------------------------------------------- Sensitivity: 0.9135802469135802 Specificity: 0.9865642994241842 False_positive_rate: 0.009633911368015413 False_negative_rate: 0.08641975308641975
Как видите, мы достигли точности 98%, что очень хорошо.
Так что это было все для демонстрации глубокого обучения.
Теперь давайте сосредоточимся на последнем модуле, где я представлю обработку естественного языка.
Что вы подразумеваете под обработкой естественного языка?
Обработка естественного языка (NLP) – это наука об извлечении полезной информации из текста на естественном языке для анализа и анализа текста.
НЛП использует концепции информатики и искусственного интеллекта для изучения данных и получения из них полезной информации. Это то, что компьютеры и смартфоны используют для понимания нашего языка, как разговорного, так и письменного.
Прежде чем мы поймем, где используется НЛП, позвольте мне прояснить распространенное заблуждение. Люди часто путаются между Text Mining и NLP.
В чем разница между Text Mining и NLP?
- Text Mining – это процесс получения полезной информации из текста.
- NLP (Обработка естественного языка) – это метод, используемый для анализа и анализа текста.
Таким образом, мы можем сказать, что текст Text Mining может осуществляться с использованием различных методологий НЛП.
Теперь давайте разберемся, где используется НЛП.
Приложения для обработки естественного языка
Вот список реальных приложений, которые используют методы НЛП:
- Сентиментальный анализ: внедряя технологических гигантов NLP, таких как Amazon и Netflix, узнайте у своих клиентов, как улучшить свои продукты, и дайте лучшие рекомендации.
- Чатбот: Чатботы становятся популярными в сфере обслуживания клиентов. Популярным примером является Eva, чат-робот HDFC, который обработал более 3 миллионов запросов клиентов, взаимодействовал с более чем полумиллионом уникальных пользователей и провел более миллиона разговоров.
- Распознавание речи: НЛП широко используется в распознавании речи, мы все знаем об Алексе, Сири, помощнике Google и Кортане. Они все приложения НЛП.
- Машинный перевод: популярный переводчик Google использует обработку естественного языка для обработки и перевода одного языка на другой. Он также используется для проверки орфографии, поиска по ключевым словам, извлечения информации.
- Соответствие рекламы: НЛП также используется в согласовании рекламы, чтобы рекомендоватьобъявления на основе истории поиска.
Теперь давайте разберемся с важными понятиями в НЛП.
Терминологии в обработке естественного языка
В этом разделе я рассмотрю все основные термины в рамках НЛП. Следующие процессы используются для анализа естественного языка с целью получения некоторых значимых идей:
Токенизация
Токенизация в основном означает разбиение данных на более мелкие порции или токены, чтобы их можно было легко анализировать.
Например, предложение «Tokens are simple» можно разбить на следующие токены:
- Tokens
- Are
- Simple
Выполняя токенизацию, вы можете понять важность каждого токена в предложении.
Стемминг
Стемминг – процесс обрезания префиксов и суффиксов слова и учета только корневого слова.
Давайте разберемся с этим на примере. Как показано на рисунке, слова,
- Обнаружение
- Детектирование
- Обнаруженный
- Обнаружения
все это может быть урезано до их корня слова, то есть обнаружить . Stemming помогает в редактировании таких слов, так что анализ документа становится проще. Тем не менее, этот процесс может быть успешным в некоторых случаях. Поэтому используется другой процесс, называемый лемматизацией.
Лемматизации
Лемматизация похожа на определение, однако она более эффективна, поскольку учитывает морфологический анализ слов. Вывод лемматизации – правильное слово.
Пример лемматизации: слова «ушел», «идет» и «ушел» переводятся в слово «уйти» с помощью лемматизации.
Стоп-Слова
Стоп-слова – это набор часто используемых слов на любом языке. Стоп-слова имеют решающее значение для анализа текста и должны быть удалены, чтобы лучше понять любой документ. Логика заключается в том, что если из документа удаляются часто используемые слова, мы можем сосредоточиться на наиболее важных словах.
Например, допустим, вы хотите сделать клубничный молочный коктейль. Если вы откроете Google и введете «как приготовить молочный коктейль из клубники», вы получите результаты «как» сделать «клубничный» молочный коктейль. Даже если вы хотите получить результаты только для клубничного молочного коктейля. Эти слова называются стоп-словами. Всегда лучше избавиться от таких слов перед выполнением любого анализа.
Источник : https://vk.com/@python_django_programirovanie-rukovodstvo-po-iskusstvennomu-intellektu-s-python