Викиконспекты - Вклад участника [ru]

Примеры кода на Java

2019-04-09T00:41:18Z

91.215.123.110:

Обзор библиотек для машинного обучения на Python

2019-04-09T00:32:14Z

91.215.123.110: Отмена правки 70880, сделанной 91.215.123.110 (обсуждение)

[[File:python-logo.png|auto|thumb|Python: https://www.python.org]]

==Scikit-learn==
===Описание===
Scikit-learn<ref>[https://scikit-learn.org/stable/ Библиотека scikit-learn]</ref> {{---}} библиотека машинного обучения на языке программирования Python с открытым исходным кодом. Содержит реализации практически всех возможных преобразований, и нередко ее одной хватает для полной реализации модели. В данной библиотеки реализованы методы разбиения датасета на тестовый и обучающий, вычисление основных метрик над наборами данных, проведение [[кросс-валидации|Кросс-валидация]][на 28.01.19 не создан]. В библиотеке также есть основные алгоритмы машинного обучения: [[Линейная регрессия|линейной регрессии]][на 28.01.19 не создан] и её модификаций Лассо, гребневой регрессии, [[Метод опорных векторов (SVM)|опорных векторов]][на 28.01.19 не создан], [[Дерево решений и случайный лес|решающих деревьев и лесов]] и др. Есть и реализации основных методов [[Кластеризация|кластеризации]]. Кроме того, библиотека содержит постоянно используемые исследователями методы работы с признаками: например, понижение размерности [[Метод главных компонент (PCA)|методом главных компонент]][на 28.01.19 не создан]. Частью пакета является библиотека imblearn<ref>[https://imbalanced-learn.readthedocs.io/en/stable/index.html Библиотека imbalanced-learn]</ref>, позволяющая работать с разбалансированными выборками и генерировать новые значения.

===Примеры кода===
====Линейная регрессия====
{{Main|Линейная регрессия|l1=Линейная регрессия[на 28.01.19 не создан]}}

# Add required imports
'''import''' matplotlib.pyplot '''as''' plt
'''import''' numpy '''as''' np
'''from''' sklearn '''import''' datasets
'''from''' sklearn.linear_model '''import''' LinearRegression
'''from''' sklearn.metrics '''import''' mean_squared_error, r2_score

Загрузка датасета:
diabetes = datasets.load_diabetes()
# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

Разбиение датасета на тренировочный и тестовый:
# Split the data into training/testing sets
x_train = diabetes_X[:-20]
x_test = diabetes_X[-20:]

# Split the targets into training/testing sets
y_train = diabetes.target[:-20]
y_test = diabetes.target[-20:]

Построение и обучение модели:
lr = LinearRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
# The mean squared error
print("Mean squared error: %.2f"
% mean_squared_error(y_test, predictions))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(y_test, predictions))

> '''Mean squared error: 2548.07'''
'''Variance score: 0.47'''

Построение графика прямой, получившейся в результате работы линейной регрессии:
plt.scatter(x_test, y_test, color='black')
plt.plot(x_test, predictions, color='blue', linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()

[[File:Diabetes-sklearn.png|400px|none|super]]

====Логистическая регрессия====
{{Main|Логистическая регрессия}}

Загрузка датасета:
'''from''' sklearn.datasets '''import''' load_digits
digits = load_digits()

Вывод первых трех тренировочных данных для визуализации:
'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt

plt.figure(figsize=(20,4))
'''for''' index, (image, label) '''in''' enumerate(zip(digits.data[0:3], digits.target[0:3])):
plt.subplot(1, 3, index + 1)
plt.imshow(np.reshape(image, (8,8)), cmap=plt.cm.gray)
plt.title('Training: %i\n' % label, fontsize = 20)

[[File:Digits-sklearn.png|800px|none|super]]

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target, test_size=0.25, random_state=0)

Построение и обучение модели:
'''from''' sklearn.linear_model '''import''' LogisticRegression
lr = LogisticRegression()
lr.fit(x_train, y_train)
predictions = lr.predict(x_test)

Оценка алгоритма:
score = lr.score(x_test, y_test)
print("Score: %.3f" % score)

> '''Score: 0.953'''

====Перцептрон====
{{Main|Нейронные сети, перцептрон}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target

Разбиение датасета на тренировочный и тестовый:
'''from''' sklearn.model_selection '''import''' train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Трансформация признаков:
'''from''' sklearn.preprocessing '''import''' StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Построение и обучение модели:
'''from''' sklearn.neural_network '''import''' MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(10, 10, 10), max_iter=1000)
mlp.fit(X_train, y_train.values.ravel())
predictions = mlp.predict(X_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[ 7 0 0]'''
'''[ 0 8 1]'''
'''[ 0 2 12]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 7'''
'''1 0.80 0.89 0.84 9'''
'''2 0.92 0.86 0.89 14'''

'''micro avg 0.90 0.90 0.90 30'''
'''macro avg 0.91 0.92 0.91 30'''
'''weighted avg 0.90 0.90 0.90 30'''

====Метрический классификатор и метод ближайших соседей====
{{Main|Метрический классификатор и метод ближайших соседей#Пример использования (через scikit-learn)|l1=Метрический классификатор и метод ближайших соседей: пример через scikit-learn}}

====Дерево решений и случайный лес====
{{Main|Дерево решений и случайный лес#Примеры использования (в scikit-learn)|l1=Дерево решений и случайный лес: пример через scikit-learn}}

====Обработка естественного языка====
{{Main|Обработка естественного языка}}

Загрузка датасета:
'''from''' sklearn '''import''' fetch_20newsgroups
twenty_train = fetch_20newsgroups(subset='train', shuffle='''True''', random_state=42)

Вывод первых трех строк первого тренивочного файла и его класса:
print("\n".join(twenty_train.data[0].split("\n")[:3]))
print(twenty_train.target_names[twenty_train.target[0]])

> '''From: lerxst@wam.umd.edu (where's my thing)'''
'''Subject: WHAT car is this!?'''
'''Nntp-Posting-Host: rac3.wam.umd.edu'''

'''rec.autos'''

Построение и обучение двух моделей. Первая на основе [[Байесовская классификация | Байесовской классификации]][на 28.01.19 не создан], а вторая использует метод опорных векторов:
'''from''' sklearn.pipeline '''import''' Pipeline
'''from''' sklearn.feature_extraction.text '''import''' CountVectorizer, TfidfTransformer

'''from''' sklearn.naive_bayes '''import''' MultinomialNB
text_clf1 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', MultinomialNB()),
])

'''from''' sklearn.linear_model '''import''' SGDClassifier
text_clf2 = Pipeline([
('vect', CountVectorizer()),
('tfidf', TfidfTransformer()),
('clf', SGDClassifier(loss='hinge', penalty='l2',
alpha=1e-3, random_state=42,
max_iter=5, tol='''None''')),
])

text_clf1.fit(twenty_train.data, twenty_train.target)
text_clf2.fit(twenty_train.data, twenty_train.target)

Оценка алгоритмов:
twenty_test = fetch_20newsgroups(subset='test', shuffle='''True''', random_state=42)
docs_test = twenty_test.data
predicted1 = text_clf1.predict(docs_test)
predicted2 = text_clf2.predict(docs_test)
print("Score: %.3f" % np.mean(predicted1 == twenty_test.target))
print("Score: %.3f" % np.mean(predicted2 == twenty_test.target))

> '''Score for naive Bayes: 0.774'''
'''Score for SVM: 0.824'''

====Кросс-валилация и подбор параметров====
{{Main|Кросс-валидация}}

Возьмем предыдущий пример с обработкой естественного языка и попробуем увеличить точность алгоритма за счет кросс-валидации и подбора параметров:
'''from''' sklearn.model_selection '''import''' GridSearchCV
parameters = {
'vect__ngram_range': [(1, 1), (1, 2)],
'tfidf__use_idf': ('''True''', '''False'''),
'clf__alpha': (1e-2, 1e-3),
}

gs_clf = GridSearchCV(text_clf2, parameters, cv=5, iid='''False''', n_jobs=-1)
gs_clf = gs_clf.fit(twenty_train.data, twenty_train.target)

print("Best score: %.3f" % gs_clf.best_score_)

'''for''' param_name '''in''' sorted(parameters.keys()):
print("%s: %r" % (param_name, gs_clf.best_params_[param_name]))

> '''Best score: 0.904'''
'''clf__alpha: 0.001'''
'''tfidf__use_idf: True'''
'''vect__ngram_range: (1, 2)'''

====Метод опорных векторов (SVM)====
{{Main|Метод опорных векторов (SVM)|l1=Метод опорных векторов (SVM) [на 28.01.19 не создан]}}

Загрузка датасета:
'''from''' sklearn '''import''' datasets
iris = datasets.load_iris()

Разбиение датасета на тестовый и тренировочный:
'''from''' sklearn.model_selection '''import''' train_test_split
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25, random_state=0)

Построение и обучение модели:
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(x_train, y_train)
predictions = clf.predict(x_test)

Оценка алгоритма:
'''from''' sklearn.metrics '''import''' classification_report, confusion_matrix
print(confusion_matrix(y_test,predictions))
print(classification_report(y_test,predictions))

> '''[[13 0 0]'''
'''[ 0 15 1]'''
'''[ 0 0 9]]'''
'''precision recall f1-score support'''

'''0 1.00 1.00 1.00 13'''
'''1 1.00 0.94 0.97 16'''
'''2 0.90 1.00 0.95 9'''

'''micro avg 0.97 0.97 0.97 38'''
'''macro avg 0.97 0.98 0.97 38'''
'''weighted avg 0.98 0.97 0.97 38'''

====EM-алгоритм====
{{Main|EM-алгоритм|l1=EM-алгоритм[на 28.01.19 не создан]}}

'''import''' numpy '''as''' np
'''import''' matplotlib.pyplot '''as''' plt
'''from''' matplotlib.colors '''import''' LogNorm
'''from''' sklearn '''import''' mixture

n_samples = 300

# generate random sample, two components
np.random.seed(0)

# generate spherical data centered on (20, 20)
shifted_gaussian = np.random.randn(n_samples, 2) + np.array([20, 20])

# generate zero centered stretched Gaussian data
C = np.array([[0., -0.7], [3.5, .7]])
stretched_gaussian = np.dot(np.random.randn(n_samples, 2), C)

# concatenate the two datasets into the final training set
X_train = np.vstack([shifted_gaussian, stretched_gaussian])

# fit a Gaussian Mixture Model with two components
clf = mixture.GaussianMixture(n_components=2, covariance_type='full')
clf.fit(X_train)

# display predicted scores by the model as a contour plot
x = np.linspace(-20., 30.)
y = np.linspace(-20., 40.)
X, Y = np.meshgrid(x, y)
XX = np.array([X.ravel(), Y.ravel()]).T
Z = -clf.score_samples(XX)
Z = Z.reshape(X.shape)

CS = plt.contour(X, Y, Z, norm=LogNorm(vmin=1.0, vmax=1000.0),
levels=np.logspace(0, 3, 10))
CB = plt.colorbar(CS, shrink=0.8, extend='both')
plt.scatter(X_train[:, 0], X_train[:, 1], .8)

plt.title('Negative log-likelihood predicted by a GMM')
plt.axis('tight')
plt.show()

[[File:Em.png|400px|none|super]]

====Уменьшение размерности====
{{Main|Уменьшение размерности#Пример кода scikit-learn|l1=Уменьшение размерности: пример через scikit-learn}}

==Tensorflow==
===Описание===
Tensorflow<ref>[https://www.tensorflow.org Библиотека Tensorflow]</ref> {{---}} библиотека, разработанная корпорацией Google для работы с тензорами, используется для построения нейронных сетей. Поддержка вычислений на видеокартах имеет поддержку языка программирования C++. На основе данной библиотеки строятся более высокоуровневые библиотеки для работы с нейронными сетями на уровне целых слоев. Так, некоторое время назад популярная библиотека Keras стала использовать Tensorflow как основной бэкенд для вычислений вместо аналогичной библиотеки Theano. Для работы на видеокартах NVIDIA используется библиотека cuDNN. Если вы работаете с картинками (со сверточными нейросетями), скорее всего, придется использовать данную библиотеку.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации цифр из датасета MNIST:
'''from''' __future__ '''import''' division, print_function, absolute_import
'''import''' tensorflow '''as''' tf

# Import MNIST data
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot='''True''')

# Training Parameters
learning_rate = 0.001
num_steps = 200
batch_size = 128
display_step = 10

# Network Parameters
num_input = 784 # MNIST data input (img shape: 28*28)
num_classes = 10 # MNIST total classes (0-9 digits)
dropout = 0.75 # Dropout, probability to keep units

# tf Graph input
X = tf.placeholder(tf.float32, ['''None''', num_input])
Y = tf.placeholder(tf.float32, ['''None''', num_classes])
keep_prob = tf.placeholder(tf.float32) # dropout (keep probability)

# Create some wrappers for simplicity
'''def''' conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
x = tf.nn.bias_add(x, b)
'''return''' tf.nn.relu(x)

'''def''' maxpool2d(x, k=2):
# MaxPool2D wrapper
'''return''' tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='SAME')

# Create model
'''def''' conv_net(x, weights, biases, dropout):
# MNIST data input is a 1-D vector of 784 features (28*28 pixels)
# Reshape to match picture format [Height x Width x Channel]
# Tensor input become 4-D: [Batch Size, Height, Width, Channel]
x = tf.reshape(x, shape=[-1, 28, 28, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
'''return''' out

# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 32 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),
# 5x5 conv, 32 inputs, 64 outputs
'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([1024, num_classes]))
}

biases = {
'bc1': tf.Variable(tf.random_normal([32])),
'bc2': tf.Variable(tf.random_normal([64])),
'bd1': tf.Variable(tf.random_normal([1024])),
'out': tf.Variable(tf.random_normal([num_classes]))
}

# Construct model
logits = conv_net(X, weights, biases, keep_prob)
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
'''with''' tf.Session() '''as''' sess:
# Run the initializer
sess.run(init)
'''for''' step '''in''' '''range'''(1, num_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y, keep_prob: 0.8})
'''if''' step % display_step == 0 '''or''' step == 1:
# Calculate batch loss and accuracy
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
Y: batch_y,
keep_prob: 1.0})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")
# Calculate accuracy for 256 MNIST test images
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: mnist.test.images[:256],
Y: mnist.test.labels[:256],
keep_prob: 1.0}))

> '''Step 1, Minibatch Loss= 41724.0586, Training Accuracy= 0.156'''
'''Step 10, Minibatch Loss= 17748.7500, Training Accuracy= 0.242'''
'''Step 20, Minibatch Loss= 8307.6162, Training Accuracy= 0.578'''
'''Step 30, Minibatch Loss= 3108.5703, Training Accuracy= 0.766'''
'''Step 40, Minibatch Loss= 3273.2749, Training Accuracy= 0.727'''
'''Step 50, Minibatch Loss= 2754.2861, Training Accuracy= 0.820'''
'''Step 60, Minibatch Loss= 2467.7925, Training Accuracy= 0.844'''
'''Step 70, Minibatch Loss= 1423.8140, Training Accuracy= 0.914'''
'''Step 80, Minibatch Loss= 1651.4656, Training Accuracy= 0.875'''
'''Step 90, Minibatch Loss= 2105.9263, Training Accuracy= 0.867'''
'''Step 100, Minibatch Loss= 1153.5090, Training Accuracy= 0.867'''
'''Step 110, Minibatch Loss= 1751.1400, Training Accuracy= 0.898'''
'''Step 120, Minibatch Loss= 1446.2119, Training Accuracy= 0.922'''
'''Step 130, Minibatch Loss= 1403.7135, Training Accuracy= 0.859'''
'''Step 140, Minibatch Loss= 1089.7897, Training Accuracy= 0.930'''
'''Step 150, Minibatch Loss= 1147.0751, Training Accuracy= 0.898'''
'''Step 160, Minibatch Loss= 1963.3733, Training Accuracy= 0.883'''
'''Step 170, Minibatch Loss= 1544.2725, Training Accuracy= 0.859'''
'''Step 180, Minibatch Loss= 977.9219, Training Accuracy= 0.914'''
'''Step 190, Minibatch Loss= 857.7977, Training Accuracy= 0.930'''
'''Step 200, Minibatch Loss= 430.4735, Training Accuracy= 0.953'''
'''Optimization Finished!'''
'''Testing Accuracy: 0.94140625'''

==Keras==
===Описание===
Keras<ref>[https://keras.io Библиотека Keras]</ref> {{---}} библиотека для построения нейронных сетей, поддерживающая основные виды слоев и структурные элементы. Поддерживает как рекуррентные, так и сверточные нейросети, имеет в своем составе реализацию известных архитектур нейросетей (например, VGG16). Некоторое время назад слои из данной библиотеки стали доступны внутри библиотеки Tensorflow. Существуют готовые функции для работы с изображениями и текстом. Интегрирована в Apache Spark с помощью дистрибутива dist-keras. Данная библиотека позволяет на более высоком уровне работать с нейронными сетями. В качестве библиотеки для бэкенда может использоваться как Tensorflow, так и Theano.
===Примеры кода===
====Сверточная нейронная сеть====
{{Main|Сверточные нейронные сети}}

Реализация сверточной нейронной сети для классификации текста:
'''from''' __future__ '''import''' print_function
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Dropout, Activation
'''from''' keras.layers '''import''' Embedding
'''from''' keras.layers '''import''' Conv1D, GlobalMaxPooling1D
'''from''' keras.datasets '''import''' imdb

# set parameters:
max_features = 5000
maxlen = 400
batch_size = 32
embedding_dims = 50
filters = 250
kernel_size = 3
hidden_dims = 250
epochs = 2

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)
print(len(x_train), 'train sequences')
print(len(x_test), 'test sequences')

> '''25000 train sequences'''
'''25000 test sequences'''

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
print('x_train shape:', x_train.shape)
print('x_test shape:', x_test.shape)

> '''Pad sequences (samples x time)'''
'''x_train shape: (25000, 400)'''
'''x_test shape: (25000, 400)'''

model = Sequential()

model.add(Embedding(max_features,
embedding_dims,
input_length=maxlen))
model.add(Dropout(0.2))
model.add(Conv1D(filters,
kernel_size,
padding='valid',
activation='relu',
strides=1))
model.add(GlobalMaxPooling1D())
model.add(Dense(hidden_dims))
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('sigmoid'))

model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))

> '''Train on 25000 samples, validate on 25000 samples'''
'''Epoch 1/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.4107 - acc: 0.7923 - val_loss: 0.2926 - val_acc: 0.8746'''
'''Epoch 2/2'''
'''25000/25000 [==============================] - 136s 5ms/step - loss: 0.2294 - acc: 0.9082 - val_loss: 0.3200 - val_acc: 0.8652'''

==Другие библиотеки для машинного обучения на Python==
===Вспомогательные библиотеки===
* NumPy<ref>[http://www.numpy.org Библиотека NumPy]</ref> {{---}} библиотека, добавляющая поддержку больших многомерных массивов и матриц вместе с большой библиотекой высокоуровневых математических функций для операций с этими массивами. Данная библиотека предоставляет реализации вычислительных алгоритмов (в виде функций и операторов), оптимизированные для работы с многомерными массивами. В результате любой алгоритм, который может быть выражен в виде последовательности операций над массивами (матрицами) и реализованный с использованием NumPy, работает так же быстро, как эквивалентный код, выполняемый в MATLAB<ref>[https://www.mathworks.com/products/matlab.html MATLAB]</ref>;
* SciPy<ref>[https://www.scipy.org Библиотека SciPy]</ref> {{---}} открытая библиотека высококачественных научных инструментов для языка программирования Python. SciPy содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке;
* Pandas<ref>[https://pandas.pydata.org Библиотека Pandas]</ref> {{---}} библиотека Python, которая является мощным инструментом для анализа данных. Пакет дает возможность строить сводные таблицы, выполнять группировки, предоставляет удобный доступ к табличным данным и позволяет строить графики на полученных наборах данных при помощи библиотеки Matplotlib;
* Matplotlib<ref>[https://matplotlib.org Библиотека Matplotlib]</ref> {{---}} библиотека Python для построения качественных двумерных графиков. Matplotlib является гибким, легко конфигурируемым пакетом, который вместе с NumPy, SciPy и IPython<ref>[https://ipython.org IPython Notebook]</ref> предоставляет возможности, подобные MATLAB.

===Библиотеки для глубокого обучения===
* PyTorch<ref>[https://pytorch.org Библиотека PyTorch]</ref> {{---}} библиотека для глубокого обучения, созданная на базе Torch<ref>[https://en.wikipedia.org/wiki/Torch_(machine_learning) Torch]</ref> и развиваемая компанией Facebook. Две ключевые функциональности данной библиотеки {{---}} тензорные вычисления с развитой поддержкой ускорения на GPU и глубокие нейронные сети на базе системы autodiff;
* Theano<ref>[http://deeplearning.net/software/theano/ Библиотека Theano]</ref> {{---}} расширение языка программирования Python, позволяющее эффективно вычислять математические выражения, содержащие многомерные массивы. Библиотека предоставляет базовый набор инструментов для конфигурации нейронных сетей и их обучения. Наибольшее признание данная библиотека получила в задачах машинного обучения при решении задач оптимизации. Она позволяет использовать возможности GPU без изменения кода программы, что делает ее незаменимой при выполнении ресурсоемких задач;
* Caffe<ref>[http://caffe.berkeleyvision.org Библиотека Caffe]</ref> {{---}} фреймворк для обучения нейронных сетей, созданный университетом Беркли. Как и Tensorflow, использует cuDNN для работы с видеокартами NVIDIA;
* Microsoft Cognitive Toolkit (CNTK)<ref>[https://www.microsoft.com/en-us/cognitive-toolkit/ Библиотека CNTK]</ref> {{---}} фреймворк от корпорации Microsoft, предоставляющий реализации архитектур различных нейронных сетей.

===Библиотеки для обработки естественного языка===
* NLTK<ref>[https://www.nltk.org Библиотека NLTK]</ref> {{---}} пакет библиотек и программ для символьной и статистической обработки естественного языка, написанных на языке программирования Python;
* Gensim<ref>[https://radimrehurek.com/gensim/ Библиотека Gensim]</ref> {{---}} инструмент для автоматической обработки языка, основанный на машинном обучении. В Gensim реализованы алгоритмы дистрибутивной семантики word2vec и doc2vec, он позволяет решать задачи тематического моделирования и выделять основные темы текста или документа.

===Библиотеки для градиентного бустинга===
* [[XGBoost|Xgboost]][на 28.01.19 не создан]<ref>[https://xgboost.readthedocs.io/en/latest/python/index.html Библиотека Xgboost]</ref> {{---}} библиотека с реализацией градиентного бустинга, которая для выбора разбиения использует сортировку и модели, основанные на анализе гистограмм;
* LightGBM<ref>[http://www.dmtk.io Библиотека LightGBM]</ref> {{---}} фреймворк с реализацией градиентного бустинга от корпорации Microsoft. Является частью проекта Microsoft DMTK, посвященного реализации подходов машинного обучения для .Net;
* [[CatBoost|CatBoost]]<ref>[https://catboost.ai Библиотека CatBoost]</ref> {{---}} библиотека с градиентным бустингом от компании Яндекс, в которой реализуется особый подход к обработке категориальных признаков, основанный на подмене категориальных признаков статистиками на основе предсказываемого значения.

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 28.01.19 не создан]
*[[:Примеры кода на Java|Примеры кода на Java]]

==Примечания==
<references/>

[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Java

2019-04-09T00:15:13Z

91.215.123.110:

Рекуррентные нейронные сети

2019-04-09T00:15:08Z

91.215.123.110: /* Пример кода */

'''Рекуррентная нейронная сеть''' (англ. ''recurrent neural network'', ''RNN'') {{---}} вид [[:Нейронные_сети,_перцептрон|нейронных сетей]], где связи между элементами образуют направленную последовательность.

== Описание ==
[[File:RNN.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ RNN и ее развернутое представление]]]
[[File:RNN_layer.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоя рекуррентной сети]]]
Рекуррентные нейронные сети {{---}} сети с циклами, которые хорошо подходят для обработки последовательностей.
[[File:RNN_BP.jpg|450px|thumb|RNN с задержкой на скрытом слое]]
[[File:RNN_BPTT.jpg|450px|thumb|Развертка RNN]]
Обучение RNN аналогично обучению обычной нейронной сети. Мы также используем [[:Обратное_распространение_ошибки|алгоритм обратного распространения ошибки (backpropagation)]][на 28.01.19 не создан], но с небольшим изменением. Поскольку одни и те же параметры используются на всех временных этапах в сети, градиент на каждом выходе зависит не только от расчетов текущего шага, но и от предыдущих временных шагов. Например, чтобы вычислить градиент для четвертого элемента последовательности, нам нужно было бы «распространить ошибку» на 3 шага и суммировать градиенты. Этот алгоритм называется «алгоритмом обратного распространения ошибки сквозь время» (англ. Backpropagation Through Time, BPTT).<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref>

Алгоритм обратного распространения ошибки сквозь время:

[[File:RNN_BPTT_GRAD.png|400px|frameless]]

== Области и примеры применения ==
Используются, когда важно соблюдать последовательность, когда важен порядок поступающих объектов.
* Обработка текста на естественном языке:
** Анализ текста;
** Автоматический перевод;
* Обработка аудио:
** Автоматическое распознавание речи;
* Обработка видео:
** Прогнозирование следующего кадра на основе предыдущих;
** Распознавание эмоций;
* Обработка изображений:
** Прогнозирование следующего пикселя на основе окружения;
** Генерация описания изображений.

== Виды RNN ==
=== Один к одному ===
{|
|-
|[[File:RNN_OTO.jpg|100px|left]]
|Архитектура по сути является обычной нейронной сетью.
|}

=== Один ко многим ===
{|
|-
|[[File:RNN_OTM.jpg|100px|left]]
|Один вход ко многим выходам может применяться, например, для генерации аудиозаписи. На вход подаем жанр музыки, который хотим получить, на выходе получаем последовательность аудиозаписи.
|}

=== Многие к одному ===
{|
|-
|[[File:RNN_MTO.jpg|100px|left]]
|Много входов и один выход может применяться, если мы хотим оценить тональность рецензии. На вход подаем слова рецензии, на выходе получаем оценку ее тональности: позитивная рецензия или негативная.
|}

=== Многие ко многим ===
{|
|-
|[[File:RNN_MTM1.jpg|100px|left]]
|Данную архитектуру можно использовать для перевода текста с одного языка на другой.
|-
|[[File:RNN_MTM2.jpg|100px|left]]
|Такой вариант подойдет для определения для классификации каждого слова в предложении в зависимости от контекста.
|}

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

=== Рекурсивная сеть ===
[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан] представляют собой более общий случай рекуррентных сетей, когда сигнал в сети проходит через структуру в виде дерева (обычно бинарные деревья). Те же самые матрицы весов используются рекурсивно по всему графу в соответствии с его топологией.

=== Нейронная сеть Хопфилда ===
Тип рекуррентной сети, когда все соединения симметричны. Изобретена Джоном Хопфилдом в 1982 году и гарантируется, что динамика такой сети сходится к одному из положений равновесия.

=== Двунаправленная ассоциативная память (BAM) ===
Вариацией сети Хопфилда является двунаправленная ассоциативная память (BAM). BAM имеет два слоя, каждый из которых может выступать в качестве входного, находить (вспоминать) ассоциацию и генерировать результат для другого слоя.
[[File:Elman_RNN.jpg|450px|thumb|Сеть Элмана]]

=== Сеть Элмана ===
Нейронная сеть Элмана состоит из трёх слоев: x, y, z (см рис. Сеть Элмана). Дополнительно к сети добавлен набор «контекстных блоков»: u (см рис. Сеть Элмана). Средний (скрытый) слой соединён с контекстными блоками с фиксированным весом, равным единице. С каждым шагом времени на вход поступает информация, которая проходит прямой ход к выходному слою в соответствии с правилами обучения. Фиксированные обратные связи сохраняют предыдущие значения скрытого слоя в контекстных блоках (до того как скрытый слой поменяет значение в процессе обучения). Таким способом сеть сохраняет своё состояние, что может использоваться в предсказании последовательностей, выходя за пределы мощности многослойного перцептрона.

<math>h_t = \sigma_h(W_h x_t + U_h h_{t-1} + b_h)</math>,

<math>y_t = \sigma_y(W_y h_t + b_y)</math>,

Обозначения переменных и функций:
* <math>x_t</math>: вектор входного слоя;
* <math>h_t</math>: вектор скрытого слоя;
* <math>y_t</math>: вектор выходного слоя;
* <math>W, U, b</math>: матрица и вектор параметров;
* <math>\sigma_h, \sigma_y</math>: функция активации.

=== Сеть Джордана ===
Нейронная сеть Джордана подобна сети Элмана, но контекстные блоки связаны не со скрытым слоем, а с выходным слоем. Контекстные блоки таким образом сохраняют своё состояние. Они обладают рекуррентной связью с собой.

<math>h_t = \sigma_h(W_h x_t + U_h y_{t-1} + b_h)</math>,

<math>y_t = \sigma_y(W_y h_t + b_y)</math>,

=== Эхо-сети ===
Эхо-сеть (англ. Echo State Network, ESN) характеризуется одним скрытым слоем (который называется резервуаром) со случайными редкими связями между нейронами. При этом связи внутри резервуара фиксированы, но связи с выходным слоем подлежат обучению. Состояние резервуара (state) вычисляется через предыдущие состояния резервуара, а также предыдущие состояния входного и выходного сигналов. Так как эхо-сети обладают только одним скрытым слоем, они обладают достаточно низкой вычислительной сложностью.

=== Нейронный компрессор истории ===
Нейронный компрессор исторических данных {{---}} это блок, позволяющий в сжатом виде хранить существенные исторические особенности процесса, который является своего рода стеком рекуррентной нейронной сети, формируемым в процессе самообучения.
[[File:LSTM.png|450px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев рекуррентной сети долго-краткосрочной памяти]]]

=== Сети долго-краткосрочной памяти ===
[[:Долгая_краткосрочная_память|Сеть долго-краткосрочной памяти]] (англ. Long short-term memory, LSTM) является самой популярной архитектурой рекуррентной нейронной сети на текущий момент, такая архитектура способна запоминать данные на долгое время.<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref>

=== Управляемые рекуррентные блоки ===
Управляемые рекуррентные блоки (англ. Gated Recurrent Units, GRU) {{---}} обладает меньшим количеством параметров, чем у LSTM, и в ней отсутствует выходное управление. При этом производительность в моделях речевого сигнала или полифонической музыки оказалась сопоставимой с LSTM.

== Пример кода ==
===Пример кода на Python с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN]</ref>===

# Импорты
'''import''' numpy '''as''' np
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Activation, Embedding
'''from''' keras.layers '''import''' LSTM
'''from''' keras.datasets '''import''' imdb

# Устанавливаем seed для обеспечения повторяемости результатов
np.random.seed(42)

# Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)
max_features = 5000

# Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)

# Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины
maxlen = 80

# Заполняем короткие рецензии пробелами, а длинные обрезаем
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)

# Создаем модель последовательной сети
model = Sequential()
# Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)
model.add(Embedding(max_features, 32, dropout = 0.2))
# Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)
model.add(LSTM(100, dropout_W = 0.2, dropout_U = 0.2))
# Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию
model.add(Dense(1, activation = 'sigmoid'))

# Компилируем модель нейронной сети
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam',
metrics = ['accuracy'])

# Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)
model.fit(X_train, y_train,
batch_size = 64,
nb_epoch = 7,
validation_data = (X_test, y_test),
verbose = 1)

# Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)
scores = model.evaluate(X_test, y_test, batch_size = 64)
print('Точность на тестовых данных: %.2f%%' % (scores[1] * 100))

===Пример на языке Java===
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.

==См. также==
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Рекуррентные нейронные сети]]

Долгая краткосрочная память

2019-04-09T00:14:13Z

91.215.123.110: /* Примеры кода */

'''Долгая краткосрочная память''' (англ. ''Long short-term memory'', ''LSTM'') {{---}} особая разновидность архитектуры [[:Рекуррентные_нейронные_сети|рекуррентных нейронных сетей]], способная к обучению долговременным зависимостям, предложенная в 1997 году Сеппом Хохрайтером и Юргеном Шмидхубером<ref name=LSTM>[https://www.bioinf.jku.at/publications/older/2604.pdf Sepp Hochreiter, Jurgen Schmidhuber. Long short-term memory (1997). Neural Computation.]</ref>.

== Описание ==
[[File:LSTM.png|650px|thumb|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Схема слоев долго-краткосрочной памяти]]]
[[:Рекуррентные_нейронные_сети|Рекуррентные нейронные сети]] добавляют память к искуственным нейронным сетям, но реализуемая память получается короткой {{---}} на каждом шаге обучения информация в памяти смешивается с новой и через несколько итераций полностью перезаписывается.

LSTM-модули разработаны специально, чтобы избежать проблемы долговременной зависимости, запоминая значения как на короткие, так и на длинные промежутки времени. Это объясняется тем, что LSTM-модуль не использует функцию активации внутри своих рекуррентных компонентов. Таким образом, хранимое значение не размывается во времени и градиент не исчезает при использовании метода обратного распространения ошибки во времени (англ. Backpropagation Through Time, BPTT)<ref name=BPTT_1>[http://andrew.gibiansky.com/blog/machine-learning/recurrent-neural-networks/ Backpropagation Through Time]</ref><ref name=BPTT_2>[http://www.wildml.com/2015/10/recurrent-neural-networks-tutorial-part-3-backpropagation-through-time-and-vanishing-gradients/ Backpropagation Through Time]</ref> при тренировке сети.

Ключевые компоненты LSTM-модуля: состояние ячейки и различные фильтры. О состоянии ячейки можно говорить, как о памяти сети, которая передает соответствующую информацию по всей цепочке модулей. Таким образом, даже информация из ранних временных шагов может быть получена на более поздних, нивелируя эффект кратковременной памяти.
[[File:Lstm-cell-state.png|none|250px|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Состояние ячейки]]]
По мере того, как происходит обучение, состояние ячейки изменяется, информация добавляется или удаляется из состояния ячейки структурами, называемыми фильтрами. Фильтры контролируют поток информации на входах и на выходах модуля на основании некоторых условий. Они состоят из слоя сигмоидальной<ref name=Sigmoid_function>[https://en.wikipedia.org/wiki/Sigmoid_function Сигмоида.]</ref> нейронной сети и операции поточечного умножения.
[[File:Lstm-gates.png|none|100px|[http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Фильтры]]]
Сигмоидальный слой возвращает числа в диапазоне [0; 1], которые обозначают, какую долю каждого блока информации следует пропустить дальше по сети. Умножение на это значение используется для пропуска или запрета потока информации внутрь и наружу памяти. Например, входной фильтр контролирует меру вхождения нового значения в память, а фильтр забывания контролирует меру сохранения значения в памяти. Выходной фильтр контролирует меру того, в какой степени значение, находящееся в памяти, используется при расчёте выходной функции активации.

== Основные компоненты ==
* Состояние ячейки
* Фильтры, контролирующие состояние ячейки
** Забывания
** Входной
** Выходной

== Принцип работы ==

Сперва “слой фильтра забывания” (англ. ''forget gate layer'') определяет, какую информацию можно забыть или оставить. Значения предыдущего выхода <math>h_{t-1}</math> и текущего входа <math>x_t</math> пропускаются через сигмоидальный слой. Полученные значения находятся в диапозоне [0; 1]. Значения, которые ближе к 0 будут забыты, а к 1 оставлены.
[[File:Lstm-1.png|none|650px]]

Далее решается, какая новая информация будет храниться в состоянии ячейки. Этот этап состоит из двух частей. Сначала сигмоидальный слой под названием “слой входного фильтра” (англ. ''input layer gate'') определяет, какие значения следует обновить. Затем tanh-слой<ref name=Hyperbolic_function>[https://en.wikipedia.org/wiki/Hyperbolic_function Гиперболические функции.]</ref> строит вектор новых значений-кандидатов <math>\tilde{C}_t</math>, которые можно добавить в состояние ячейки.
[[File:Lstm-2.png|none|650px]]

Для замены старого состояния ячейки <math>C_{t-1}</math> на новое состояние <math>C_t</math>. Необходимо умножить старое состояние на <math>f_t</math>, забывая то, что решили забыть ранее. Затем прибавляем <math>i_t * \tilde{C}_t</math>. Это новые значения-кандидаты, умноженные на <math>t</math> – на сколько обновить каждое из значений состояния.
[[File:Lstm-3.png|none|650px]]

На последнем этапе определяется то, какая информация будет получена на выходе. Выходные данные будут основаны на нашем состоянии ячейки, к ним будут применены некоторые фильтры. Сначала значения предыдущего выхода <math>h_{t-1}</math> и текущего входа <math>x_t</math> пропускаются через сигмоидальный слой, который решает, какая информация из состояния ячейки будет выведена. Затем значения состояния ячейки проходят через tanh-слой, чтобы получить на выходе значения из диапазона от -1 до 1, и перемножаются с выходными значениями сигмоидального слоя, что позволяет выводить только требуемую информацию.
[[File:Lstm-4.png|none|650px]]

Полученные таким образом <math>h_t</math> и <math>C_t</math> передаются далее по цепочке.

== Вариации ==
=== Cмотровые глазки ===
Одна из популярных вариаций LSTM, предложенная Герсом и Шмидхубером<ref name=LSTM-peephole-connections>[ftp://ftp.idsia.ch/pub/juergen/TimeCount-IJCNN2000.pdf Gers, Schmidhuber. Recurrent Nets that Time and Count (2000).]</ref>, характеризуется добавлением так называемых “смотровых глазков” (англ. ''peephole connections''). С их помощью слои фильтров могут видеть состояние ячейки.
[[File:Lstm-peephole-connections.png|none|650px]]
На схеме выше “глазки” есть у каждого слоя, но во многих работах они добавляются лишь к некоторым слоям.

=== Объединенные фильтры ===
Другие модификации включают объединенные фильтры “забывания” и входные фильтры. В этом случае решения, какую информацию следует забыть, а какую запомнить, принимаются не отдельно, а совместно. Информация забывается только тогда, когда необходимо записать что-то на её место. Добавление новой информации в состояние ячейки выполняется только тогда, когда забываем старую.
[[File:Lstm-mod-1.png|none|650px]]

=== Управляемые рекуррентные нейроны ===
Немного больше отличаются от стандартных LSTM управляемые рекуррентные нейроны (англ. ''Gated recurrent units, GRU''), впервые описанные в работе Кюнгхюна Чо (англ. Kyunghyun Cho)<ref name=Cho>[https://arxiv.org/pdf/1406.1078v3.pdf Cho. Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation (2014).]</ref>. У них на один фильтр меньше, и они немного иначе соединены. Фильтры «забывания» и входа объединяют в один фильтр «обновления» (англ. ''update gate''). Этот фильтр определяет сколько информации сохранить от последнего состояния, и сколько информации получить от предыдущего слоя. Кроме того, состояние ячейки объединяется со скрытым состоянием, есть и другие небольшие изменения. Фильтр сброса состояния (англ. ''reset gate'') работает почти так же, как фильтр забывания, но расположен немного иначе. На следующие слои отправляется полная информация о состоянии, выходного фильтра нет. В большинстве случаем GRU работают так же, как LSTM, самое значимое отличие в том, что GRU немного быстрее и проще в эксплуатации, однако обладает немного меньшими выразительными возможностями. В результате модели проще, чем LSTM и их популярность неуклонно возрастает. Эффективность при решении задач моделирования музыкальных и речевых сигналов сопоставима с использованием долгой краткосрочной памяти.
[[File:Lstm-gru.png|none|650px]]

=== Глубокие управляемые рекуррентные нейроны ===
Существует множество других модификаций, как, например, глубокие управляемые рекуррентные нейронные сети (англ. ''Depth Gated RNNs''), представленные в работе Каишенга Яо (англ. Kaisheng Yao)<ref name=Yao>[https://arxiv.org/pdf/1508.03790v2.pdf SeppKaisheng Yao. Depth-Gated Recurrent Neural Networks (2015).]</ref>. Глубокие управляемые рекуррентные нейронные сети привносят фильтр глубины для подключения ячеек памяти соседних слоев. Это вводит линейную зависимость между нижними и верхними рекуррентными единицами. Важно отметить, что линейная зависимость проходит через функцию стробирования, которая называется фильтром забывания. Данная архитектура способна улучшить машинный перевод и языковое моделирование.

=== Механизм часов ===
Есть и другие способы решения проблемы долговременных зависимостей, например, механизм часов (англ. ''Clockwork RNN'', CW-RNN) Яна Кутника<ref name=Jan>[https://arxiv.org/pdf/1402.3511v1.pdf Jan Koutnik. A Clockwork RNN (2014).]</ref>. CW-RNN {{---}} мощная модификация стандартной архитектуры RNN, в которой скрытый слой разделен на отдельные модули, каждый из которых обрабатывает входные данные со своей временной детализацией, производя вычисления только при заданной тактовой частоте. Стандартная модель RNN не ставновится сложнее, CW-RNN уменьшает количество параметров RNN, улучшает точность и скорость обучения сети в задачах генерации звуковых сигналов.

== Примеры кода ==
=== Keras ===
Пример кода с использованием библиотеки Keras.<ref name=KerasRNN>[https://keras.io/layers/recurrent/ Keras RNN with LSTM layer]</ref>

# Импорты
'''import''' numpy '''as''' np
'''import''' keras.backend '''as''' K
'''from''' keras.preprocessing '''import''' sequence
'''from''' keras.models '''import''' Sequential
'''from''' keras.layers '''import''' Dense, Activation, Embedding
'''from''' keras.layers '''import''' LSTM
'''from''' keras.datasets '''import''' imdb

'''def''' f1(y_true, y_pred):
'''def''' recall(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives / (possible_positives + K.epsilon())
return recall

'''def''' precision(y_true, y_pred):
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
precision = true_positives / (predicted_positives + K.epsilon())
return precision

precision = precision(y_true, y_pred)
recall = recall(y_true, y_pred)
return 2*((precision*recall)/(precision+recall+K.epsilon()))

# Устанавливаем seed для обеспечения повторяемости результатов
np.random.seed(42)

# Указываем количество слов из частотного словаря, которое будет использоваться (отсортированы по частоте использования)
max_features = 5000

# Загружаем данные (датасет IMDB содержит 25000 рецензий на фильмы с правильным ответом для обучения и 25000 рецензий на фильмы с правильным ответом для тестирования)
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words = max_features)

# Устанавливаем максимальную длину рецензий в словах, чтобы они все были одной длины
maxlen = 80

# Заполняем короткие рецензии пробелами, а длинные обрезаем
X_train = sequence.pad_sequences(X_train, maxlen = maxlen)
X_test = sequence.pad_sequences(X_test, maxlen = maxlen)

# Создаем модель последовательной сети
model = Sequential()
# Добавляем слой для векторного представления слов (5000 слов, каждое представлено вектором из 32 чисел, отключаем входной сигнал с вероятностью 20% для предотвращения переобучения)
model.add(Embedding(max_features, 32, dropout = 0.2))
# Добавляем слой долго-краткосрочной памяти (100 элементов для долговременного хранения информации, отключаем входной сигнал с вероятностью 20%, отключаем рекуррентный сигнал с вероятностью 20%)
model.add(LSTM(100, dropout_W = 0.2, dropout_U = 0.2))
# Добавляем полносвязный слой из 1 элемента для классификации, в качестве функции активации будем использовать сигмоидальную функцию
model.add(Dense(1, activation = 'sigmoid'))

# Компилируем модель нейронной сети
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam',
metrics = ['accuracy', 'f1'])

# Обучаем нейронную сеть (данные для обучения, ответы к данным для обучения, количество рецензий после анализа которого будут изменены веса, число эпох обучения, тестовые данные, показывать progress bar или нет)
model.fit(X_train, y_train,
batch_size = 64,
nb_epoch = 7,
validation_data = (X_test, y_test),
verbose = 1)

# Проверяем качество обучения на тестовых данных (если есть данные, которые не участвовали в обучении, лучше использовать их, но в нашем случае таковых нет)
scores = model.evaluate(X_test, y_test, batch_size = 64)
print('Точность на тестовых данных: %.2f%%' % (scores[1] * 100))
print('F1 на тестовых данных: %.2f%%' % (scores[2] * 100))

Результат:
Точность на тренировочных данных: 89.64%
F1 на тренировочных данных: 89.55%

Точность на тестовых данных: 83.01%
F1 на тестовых данных: 82.48%

=== TensorFlow ===
Пример кода с библиотекой TensorFlow<ref>[https://www.tensorflow.org/ TensorFlow]</ref>

# Импорты
'''from''' __future__ '''import''' print_function
'''import''' tensorflow '''as''' tf
'''from''' tensorflow.contrib '''import''' rnn

# Импорт MNIST датасета
'''from''' tensorflow.examples.tutorials.mnist '''import''' input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)

# Определение параметров обучения
learning_rate = 0.001
training_steps = 10000
batch_size = 128
display_step = 200

# Определение параметров сети
num_input = 28
timesteps = 28
num_hidden = 128
num_classes = 10

# Входные данные для графа
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, num_classes])

# Определение весов
weights = {
'out': tf.Variable(tf.random_normal([num_hidden, num_classes]))
}
biases = {
'out': tf.Variable(tf.random_normal([num_classes]))
}

def RNN(x, weights, biases):
x = tf.unstack(x, timesteps, 1)
# Определение LSTM ячейки
lstm_cell = rnn.BasicLSTMCell(num_hidden, forget_bias=1.0)
# Получение выхода LSTM ячейки
outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)
return tf.matmul(outputs[-1], weights['out']) + biases['out']

logits = RNN(X, weights, biases)
prediction = tf.nn.softmax(logits)

# Определение функции потерь и оптимизатора
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
logits=logits, labels=Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Оценка модели
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Инициализация
init = tf.global_variables_initializer()

with tf.Session() as sess:
sess.run(init)

for step in range(1, training_steps+1):
batch_x, batch_y = mnist.train.next_batch(batch_size)
batch_x = batch_x.reshape((batch_size, timesteps, num_input))
# Запуск оптимизатора (обратное распространение ошибки)
sess.run(train_op, feed_dict={X: batch_x, Y: batch_y})
if step % display_step == 0 or step == 1:
loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x, Y: batch_y})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.4f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
print("Optimization Finished!")

test_len = 128
test_data = mnist.test.images[:test_len].reshape((-1, timesteps, num_input))
test_label = mnist.test.labels[:test_len]
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))

Результат:
Точность на тренировочных данных: 91.40%
F1 на тренировочных данных: 91.05%

Точность на тестовых данных: 85.15%
F1 на тестовых данных: 84.28%

===Пример на языке Java===
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.

==См. также==
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Нейронные_сети,_перцептрон|Нейронные сети, перцептрон]]
*[[:Сверточные_нейронные_сети|Сверточные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]]

==Примечания==
<references/>

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]
[[Категория: Рекуррентные нейронные сети]]

== Источники информации ==
* [http://colah.github.io/posts/2015-08-Understanding-LSTMs/ Understanding LSTM Networks]
* [https://towardsdatascience.com/illustrated-guide-to-lstms-and-gru-s-a-step-by-step-explanation-44e9eb85bf21 Illustrated Guide to LSTM’s and GRU’s: A step by step explanation]
* [https://towardsdatascience.com/the-fall-of-rnn-lstm-2d1594c74ce0 The fall of RNN / LSTM]
* [https://en.wikipedia.org/wiki/Long_short-term_memory Long short-term memory] - статья на Википедии
* [https://www.coursera.org/lecture/nlp-sequence-models/long-short-term-memory-lstm-KXoay Long Short Term Memory (LSTM)] - курс Andrew Ng

Примеры кода на Java

2019-04-09T00:12:51Z

91.215.123.110:

Нейронные сети, перцептрон

2019-04-09T00:12:30Z

91.215.123.110: /* Пример на языке Java= */

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

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

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

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

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

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

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

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

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

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

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

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

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

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

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

==Обучение нейронной сети==

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

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

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

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

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

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

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

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

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

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

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

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'');
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1'';
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами;
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал;
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей);
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

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

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости;
* Прогнозирование и распознавание образов;
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>.

===Примеры кода===
====Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>====

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

====Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>====

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

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

====Пример на языке Java====
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

Нейронные сети, перцептрон

2019-04-09T00:12:14Z

91.215.123.110:

'''Искусственная нейронная сеть (ИНС)''' (англ. ''Artificial neural network (ANN)'') {{---}} упрощенная модель биологической нейронной сети, представляющая собой совокупность искусственных нейронов, взаимодействующих между собой.

[[File:Нейронная_сеть.png|700px|thumb|[https://neuralnet.info/chapter/%D0%B2%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5/#%D0%92-%D1%86%D0%B5%D0%BB%D0%BE%D0%BC-%D0%BE%D0%B1-%D0%98%D0%9D%D0%A1 Упрощение биологической нейронной сети]]]

Основные принципы работы нейронных сетей были описаны еще в 1943 году Уорреном Мак-Каллоком и Уолтером Питтсом<ref>[https://en.wikipedia.org/wiki/Artificial_neuron Artificial neuron, Wikipedia]</ref>. В 1957 году нейрофизиолог Фрэнк Розенблатт разработал первую нейронную сеть<ref>[https://en.wikipedia.org/wiki/Perceptron Perceptron, Wikipedia]</ref>, а в 2010 году большие объемы данных для обучения открыли возможность использовать нейронные сети для машинного обучения.

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

==Структура нейронной сети==

[[File:Искусственный_нейрон_схема.png|700px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%98%D1%81%D0%BA%D1%83%D1%81%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD Схема искусственного нейрона]]]

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

Для построения искусственной нейронной сети будем использовать ту же структуру. Как и биологическая нейронная сеть, искусственная состоит из нейронов, взаимодействующих между собой, однако представляет собой упрощенную модель. Так, например, искусственный нейрон, из которых состоит ИНС, имеет намного более простую структуру: у него есть несколько входов, на которых он принимает различные сигналы, преобразует их и передает другим нейронам. Другими словами, искусственный нейрон {{---}} это такая функция <tex>\mathbb{R}^n \rightarrow \mathbb{R}</tex>, которая преобразует несколько входных параметров в один выходной.

Как видно на рисунке справа, у нейрона есть <tex>n</tex> входов <tex>x_i</tex>, у каждого из которого есть вес <tex>w_i</tex>, на который умножается сигнал, проходящий по связи. После этого взвешенные сигналы <tex>x_i \cdot w_i</tex> направляются в сумматор, который аггрегирует все сигналы во взвешенную сумму. Эту сумму также называют <tex>net</tex>. Таким образом, <tex>net = \sum_{i=1}^{i=n} w_i \cdot x_i = w^T \cdot x</tex>.

Просто так передавать взвешенную сумму <tex>net</tex> на выход достаточно бессмысленно {{---}} нейрон должен ее как-то обработать и сформировать адекватный выходной сигнал. Для этих целей используют [[Практики реализации нейронных сетей#Функции активации|функцию активации]], которая преобразует взвешенную сумму в какое-то число, которое и будет являться выходом нейрона. Функция активации обозначается <tex>\phi(net)</tex>. Таким образом, выходов искусственного нейрона является <tex>\phi(net)</tex>.

Для разных типов нейронов используют самые разные функции активации, но одними из самых популярных являются:
* Функция единичного скачка. Если <tex>net > threshold</tex>, <tex>\phi(net) = 1</tex>, а иначе <tex>0</tex>;
* Сигмоидальная функция. <tex>\phi(net) = \frac{1}{1 + exp(-a \cdot net)}</tex>, где параметр <tex>a</tex> характеризует степень крутизны функции;
* Гиперболический тангенс. <tex>\phi(net) = tanh(\frac{net}{a})</tex>, где параметр <tex>a</tex> также определяет степень крутизны графика функции;
* Rectified linear units (ReLU). <tex>ReLU(x) = \begin{cases}
x & x \geq 0 \\
0 & x < 0
\end{cases} = \max(x, 0)</tex>.

==Виды нейронных сетей==

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

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

===Однослойные нейронные сети===

[[File:Single-layer-neural-net-scheme.png|500px|thumb|[https://studfiles.net/preview/3170620/page:3/ Схема однослойной нейронной сети]]]

'''Однослойная нейронная сеть''' (англ. ''Single-layer neural network'') {{---}} сеть, в которой сигналы от входного слоя сразу подаются на выходной слой, который и преобразует сигнал и сразу же выдает ответ.

Как видно из схемы однослойной нейронной сети, представленной справа, сигналы <tex>x_1, x_2, \ldots x_n</tex> поступают на входной слой (который не считается за слой нейронной сети), а затем сигналы распределяются на выходной слой обычных нейронов. На каждом ребре от нейрона входного слоя к нейрону выходного слоя написано число {{---}} вес соответствующей связи.

===Многослойные нейронные сети===

[[File:Multi-layer-neural-net-scheme.png|500px|thumb|[https://wiki.loginom.ru/articles/multilayer-neural-net.html Схема многослойной нейронной сети]]]

'''Многослойная нейронная сеть''' (англ. ''Multilayer neural network'') {{---}} нейронная сеть, состоящая из входного, выходного и расположенного(ых) между ними одного (нескольких) скрытых слоев нейронов.

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

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

===Сети прямого распространения===

'''Сети прямого распространения''' (англ. ''Feedforward neural network'') (feedforward сети) {{---}} искусственные нейронные сети, в которых сигнал распространяется строго от входного слоя к выходному. В обратном направлении сигнал не распространяется.

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

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

===Сети с обратными связями===

[[File:Сети_с_обратными_связями.png|400px|thumb|[https://neuralnet.info/chapter/%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D1%8B-%D0%B8%D0%BD%D1%81/#%D0%A1%D0%B5%D1%82%D0%B8-%D1%81-%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%BC%D0%B8-%D1%81%D0%B2%D1%8F%D0%B7%D1%8F%D0%BC%D0%B8 Схема сети с обратными связями]]]

'''[[Рекуррентные нейронные сети|Сети с обратными связями]]''' (англ. ''Recurrent neural network'') {{---}} искусственные нейронные сети, в которых выход нейрона может вновь подаваться на его вход. В более общем случае это означает возможность распространения сигнала от выходов к входам.

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

==Обучение нейронной сети==

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

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

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

'''Обучающая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит обучение сети.

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

'''Тестовая выборка''' {{---}} конечный набор входных сигналов (иногда вместе с правильными выходными сигналами), по которым происходит оценка качества работы сети.

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

==Перцептрон==

[[File:Перцептрон.png|350px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9F%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема перцептрона]]]

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

===История===

Идею перцептрона предложил нейрофизиолог Фрэнк Розенблатт. Он предложил схему устройства, моделирующего процесс человеческого восприятия, и назвал его ''«перцептроном»'' (от латинского ''perceptio'' {{---}} восприятие). В 1960 году Розенблатт представил первый нейрокомпьютер {{---}} «Марк-1», который был способен распознавать некоторые буквы английского алфавита.

Таким образом перцептрон является одной из первых '''моделей нейросетей''', а «Марк-1» {{---}} первым в мире '''нейрокомпьютером'''.

===Описание===

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

Принцип работы перцептрона следующий:
# Первыми в работу включаются S-элементы. Они могут находиться либо в состоянии покоя (сигнал равен ''0''), либо в состоянии возбуждения (сигнал равен ''1'');
# Далее сигналы от S-элементов передаются A-элементам по так называемым S-A связям. Эти связи могут иметь веса, равные только ''-1'', ''0'' или ''1'';
# Затем сигналы от сенсорных элементов, прошедших по S-A связям, попадают в A-элементы, которые еще называют ассоциативными элементами;
#* Одному A-элементу может соответствовать несколько S-элементов;
#* Если сигналы, поступившие на A-элемент, в совокупности превышают некоторый его порог <tex>\theta</tex>, то этот A-элемент возбуждается и выдает сигнал, равный ''1'';
#* В противном случае (сигнал от S-элементов не превысил порога A-элемента), генерируется нулевой сигнал;
# Далее сигналы, которые произвели возбужденные A-элементы, направляются к сумматору (R-элемент), действие которого нам уже известно. Однако, чтобы добраться до R-элемента, они проходят по A-R связям, у которых тоже есть веса (которые уже могут принимать любые значения, в отличие от S-A связей);
# R-элемент складывает друг с другом взвешенные сигналы от A-элементов, а затем
#* если превышен определенный порог, генерирует выходной сигнал, равный ''1'';
#* eсли порог не превышен, то выход перцептрона равен ''-1''.

Для элементов перцептрона используют следующие названия:
* S-элементы называют сенсорами;
* A-элементы называют ассоциативными;
* R-элементы называют реагирующими.

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

[[File:Однслойный_перцептрон.png|300px|thumb|[https://neuralnet.info/chapter/%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D1%8B/#%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D0%BB%D0%BE%D0%B9%D0%BD%D1%8B%D0%B9-%D0%BF%D0%B5%D1%80%D1%81%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD Схема однослойного перцептрона]]]

'''Перцептрон с одним скрытым слоем''' ('''элементарный перцептрон''', англ. ''elementary perceptron'') {{---}} перцептрон, у которого имеется только по одному слою S, A и R элементов.

'''Однослойный персептрон''' (англ. ''Single-layer perceptron'') {{---}} перцептрон, каждый S-элемент которого однозначно соответствует одному А-элементу, S-A связи всегда имеют вес ''1'', а порог любого А-элемента равен ''1''. Часть однослойного персептрона соответствует модели искусственного нейрона.

Его ключевая особенность состоит в том, что каждый S-элемент однозначно соответствует одному A-элементу, все S-A связи имеют вес, равный ''+1'', а порог A элементов равен ''1''. Часть однослойного перцептрона, не содержащая входы, соответствует искусственному нейрону, как показано на картинке. Таким образом, однослойный перцептрон {{---}} это искусственный нейрон, который на вход принимает только ''0'' и ''1''.

Однослойный персептрон также может быть и элементарным персептроном, у которого только по одному слою S,A,R-элементов.

'''Многослойный перцептрон по Розенблатту''' (англ. ''Rosenblatt multilayer perceptron'') {{---}} перцептрон, который содержит более 1 слоя А-элементов.

'''Многослойный перцептрон по Румельхарту''' (англ. ''Rumelhart multilater perceptron'') {{---}} частный случай многослойного персептрона по Розенблатту, с двумя особенностями:
* S-A связи могут иметь произвольные веса и обучаться наравне с A-R связями;
* Обучение производится по специальному алгоритму, который называется обучением по методу обратного распространения ошибки.

===Обучение перцептрона===

Задача обучения перцептрона {{---}} подобрать такие <tex>w_0, w_1, w_2, \ldots, w_n</tex>, чтобы <tex>sign(\sigma(w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n))</tex> как можно чаще совпадал с <tex>y(x)</tex> {{---}} значением в обучающей выборке (здесь <tex>\sigma</tex> {{---}} функция активации). Для удобства, чтобы не тащить за собой свободный член <tex>w_0</tex>, добавим в вектор $x$ лишнюю «виртуальную размерность» и будем считать, что <tex>x = (1, x_1, x_2, \ldots, x_n)</tex>. Тогда <tex>w_0 + w_1 \cdot x_1 + w_2 \cdot x_2 + \ldots + w_n \cdot x_n</tex> можно заменить на <tex>w^T \cdot x</tex>.

Чтобы обучать эту функцию, сначала надо выбрать функцию ошибки, которую потом можно оптимизировать [[Стохастический градиентный спуск|градиентным спуском]]. Число неверно классифицированных примеров не подходит на эту кандидатуру, потому что эта функция кусочно-гладкая, с массой разрывов: она будет принимать только целые значения и резко меняться при переходе от одного числа неверно классифицированных примеров к другому. Поэтому использовать будем другую функцию, так называемый ''критерий перцептрона'': <tex>E_P(w) = -\sum_{x \in M} y(x)(\sigma(w^T \cdot x))</tex>, где <tex>M</tex> {{---}} множество примеров, которые перцептрон с весами <tex>w</tex> классифицирует неправильно.

Иначе говоря, мы минимизируем суммарное отклонение наших ответов от правильных, но только в неправильную сторону; верный ответ ничего не вносит в функцию ошибки. Умножение на <tex>y(x)</tex> здесь нужно для того, чтобы знак произведения всегда получался отрицательным: если правильный ответ ''−1'', значит, перцептрон выдал положительное число (иначе бы ответ был верным), и наоборот. В результате у нас получилась кусочно-линейная функция, дифференцируемая почти везде, а этого вполне достаточно.

Теперь <tex>E_P(w)</tex> можно оптимизировать градиентным спуском. На очередном шаге получаем: <tex>w^{(\tau+1)} = w^{(\tau)} − \eta\triangledown_w E_P(w)</tex>.

Алгоритм такой {{---}} мы последовательно проходим примеры <tex>x_1, x_2, \ldots</tex> из обучающего множества, и для каждого <tex>x_n</tex>:
* если он классифицирован правильно, не меняем ничего;
* а если неправильно, прибавляем <tex>\eta \triangledown_w E_P(w)</tex>.

Ошибка на примере <tex>x_n</tex> при этом, очевидно, уменьшается, но, конечно, совершенно никто не гарантирует, что вместе с тем не увеличится ошибка от других примеров. Это правило обновления весов так и называется {{---}} правило обучения перцептрона, и это было основной математической идеей работы Розенблатта.

===Применение===

* Решение задач классификации, если объекты классификации обладают свойством линейной разделимости;
* Прогнозирование и распознавание образов;
* Управление агентами<ref>[https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD%D0%BE%D0%B2 Применения перцептрона, Wikipedia]</ref>.

===Примеры кода===
====Пример использования с помощью scikit-learn<ref>[https://scikit-learn.org Библиотека scikit-learn для Python]</ref>====

Будем классифицировать с помощью перцептрона датасет MNIST<ref>[https://en.wikipedia.org/wiki/MNIST_database Датасет MNIST]</ref>.

# Load required libraries
from sklearn import datasets
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Perceptron #Single-layer perceptron
from sklearn.neural_network import MLPClassifier #Multilayer perceptron
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# Load the mnist dataset
mnist = datasets.load_digits()

# Create our X and y data
n_samples = len(mnist.images)
X = mnist.images.reshape((n_samples, -1))
y = mnist.target

# Split the data into 70% training data and 30% test data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train the scaler, which standarizes all the features to have mean=0 and unit variance
sc = StandardScaler()
sc.fit(X_train)

# Apply the scaler to the X training data
X_train_std = sc.transform(X_train)

# Apply the SAME scaler to the X test data
X_test_std = sc.transform(X_test)

# Create a single-layer perceptron object with the parameters: 40 iterations (epochs) over the data, and a learning rate of 0.1
ppn = Perceptron(n_iter=40, eta0=0.1, random_state=0)
# Create a multilayer perceptron object
mppn = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(256, 512, 128), random_state=1)

# Train the perceptrons
ppn.fit(X_train_std, y_train)
mppn.fit(X_train_std, y_train)

# Apply the trained perceptrons on the X data to make predicts for the y test data
y_pred = ppn.predict(X_test_std)
multi_y_pred = mppn.predict(X_test_std)

# View the accuracies of the model, which is: 1 - (observations predicted wrong / total observations)
print('Single-layer perceptron accuracy: %.4f' % accuracy_score(y_test, y_pred))
print('Multilayer perceptron accuracy: %.4f' % accuracy_score(y_test, multi_y_pred))

Вывод:
Single-layer perceptron accuracy: 0.9574
Multilayer perceptron accuracy: 0.9759

====Пример использования с помощью tensorflow<ref>[https://www.tensorflow.org/ Библиотека tensorflow для Python]</ref>====

Будем классифицировать цифры из того же датасета MNIST.

# Load required libraries
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Load MNIST dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

#placeholder for test data
x = tf.placeholder(tf.float32, [None, 784])
#placeholder for weights and bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
#tensorflow model
y = tf.nn.softmax(tf.matmul(x, W) + b)

#loss function
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

#gradient descent step
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Accuracy: %s" % sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

[[File:Tensorflow-mnist-failures.png|400px|thumb|Правильные метки {{---}} 5, 4, 9, 7. Результат классификации {{---}} 6, 6, 4, 4.]]

Вывод:
Accuracy: 0.9164

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

====Пример на языке Java=====
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

==См. также==
*[[:Сверточные нейронные сети|Сверточные нейронные сети]]
*[[:Рекуррентные нейронные сети|Рекуррентные нейронные сети]]
*[[:Рекурсивные нейронные сети|Рекурсивные нейронные сети]][на 28.01.19 не создан]

==Примечания==
<references/>
== Источники информации ==
* Сергей Николенко, Артур Кадурин, Екатерина Архангельская. Глубокое обучение. Погружение в мир нейронных сетей. — «Питер», 2018. — С. 93-123.
* [https://neuralnet.info/book/ Нейронные сети {{---}} учебник ]

[[Категория: Машинное обучение]]
[[Категория: Нейронные сети]]

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

2019-04-09T00:07:08Z

91.215.123.110: /* Пример на языке Java */

'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.
== Описание ==
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.

Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ {{---}} конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex>,</center>
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.

Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex>,</center>

После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>,</center>
где $\sigma(z) = \frac1{1+e^{-z}}$ {{---}} сигмоидная функция.

== Обоснование ==
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]][на 28.01.19 не создан]'''

Наиболее строгое обоснование логистической регрессии опирается на следующую теорему
{{Теорема
|statement=Пусть
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex>
где $\mathrm{P}_y$ {{---}} ''априорные вероятности'',
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции);
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$;
*среди признаков есть константа, скажем, $f_0(x) = -1$;
Тогда
*линейный классификатор является оптимальным байесовским классификатором;
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>.
|proof=

Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:
<center><tex>a\left(x\right)=
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex>,</center>

Рассмотрим отношение апостериорных вероятностей классов
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex>,</center>
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex>,</center>

Рассмотрим получившуюся под экспонентой сумму:
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках;
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.

Таким образом,
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex>,</center>

Разделяющая поверхность в байесовском решающем правиле определяется уравнением
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex>,</center>
которое равносильно
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex>,</center>

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

Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex>,</center>

Откуда следует:
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex>,</center>
Таким образом, второй пункт теоремы доказан.
}}

== Примеры кода ==
=== scikit-learn ===
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:
* '''solver''' $-$ алгоритм, использующийся для оптимизации;
* '''multi_class''' $-$ классификация на 2 или много классов.

* Импортируем нужные библиотеки:
'''from''' sklearn.linear_model '''import''' LogisticRegression
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества:
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение:
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')
model = clf.'''fit'''(X_train, y_train)

* Предсказание:
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

=== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ===
===Пример на языке Java===
Пример логистической регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);

== См. также ==
* [[Байесовская классификация]][на 28.01.19 не создан]
* [[Линейная регрессия]][на 28.01.19 не создан]
* [[Вариации регрессии]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Источники информации ==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Логистическая регрессия]
* [https://en.wikipedia.org/wiki/Logistic_regression Wikipedia {{---}} Logistic regression]
* [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html scikit-learn.org {{---}} документация по sklearn.linear_model.LogisticRegression]

[[Категория: Машинное обучение]]

Примеры кода на Java

2019-04-09T00:06:50Z

91.215.123.110:

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

2019-04-09T00:06:18Z

91.215.123.110: /* Примеры кода */

'''Логистическая регрессия''' (англ. ''logistic regression'') — метод построения линейного классификатора, позволяющий оценивать апостериорные вероятности принадлежности объектов классам.
== Описание ==
Логистическая регрессия применяется для прогнозирования вероятности возникновения некоторого события по значениям множества признаков. Для этого вводится зависимая переменная $y$, принимающая значения $0$ и $1$ и множество [[Независимые случайные величины|независимых]] переменных <tex>x_1, ... x_n</tex> на основе значений которых требуется вычислить вероятность принятия того или иного значения зависимой переменной.

Итак, пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ {{---}} конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Рассмотрим случай двух классов: $Y = \{-1, +1\}$. В логистической регрессии строится линейный алгоритм классификации $a: X \to Y$ вида
<center><tex>a(x, w) = \mathrm{sign}\left(\sum\limits_{j=1}^n w_j f_j(x) - w_0 \right)=\mathrm{sign}\left<x, w\right></tex>,</center>
где $w_j$ $-$ вес $j$-го признака, $w_0$ $-$ порог принятия решения, $w=\left(w_0, ..., w_n\right)$ $-$ вектор весов, $\left<x, w\right>$ $-$ скалярное произведение признакового описания объекта на вектор весов. Предполагается, что искусственно введён нулевой признак: $f_{0}(x)=-1$.

Задача обучения линейного классификатора заключается в том, чтобы по выборке $X^m$ настроить вектор весов $w$. В логистической регрессии для этого решается задача минимизации эмпирического риска с функцией потерь специального вида: <center><tex>Q(w) = \sum\limits_{i=1}^m \ln\left( 1 + \exp( -y_i \langle x_i,w \rangle ) \right) \to \min_{w}</tex>,</center>

После того, как решение $w$ найдено, становится возможным не только вычислять классификацию $a(x) = \mathrm{sign}\langle x,w \rangle$ для произвольного объекта $x$, но и оценивать апостериорные вероятности его принадлежности классам:
<center><tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>,</center>
где $\sigma(z) = \frac1{1+e^{-z}}$ {{---}} сигмоидная функция.

== Обоснование ==
'''С точки зрения [[Байесовский классификатор|байесовского классификатора]][на 28.01.19 не создан]'''

Наиболее строгое обоснование логистической регрессии опирается на следующую теорему
{{Теорема
|statement=Пусть
*выборка прецедентов $\mathrm{X}^l=\{\left(x_1, y_1\right), ... ,\left(x_l, y_l\right)\}$ получена согласно вероятностному распределению с плотностью
<tex>p\left(x, y\right)=\mathrm{P}_yp_y\left(x\right)=\mathrm{P}\left(y|x\right)p\left(x\right)</tex>
где $\mathrm{P}_y$ {{---}} ''априорные вероятности'',
$p_y(x)$ $-$ ''функции правдоподобия'', принадлежащие экспонентному семейству плотностей (т.е. $p_y(x) = \exp \left( \langle\theta,x\rangle \cdot a(\delta) + b(\delta,\theta) + d(x,\delta) \right)$, где $a, b, d$ $-$ произвольные функции);
*функции правдоподобия имеют равные знаения параметра разброса $\delta$ и отличаются только значениями параметра сдвига $\theta_y$;
*среди признаков есть константа, скажем, $f_0(x) = -1$;
Тогда
*линейный классификатор является оптимальным байесовским классификатором;
*апостериорные вероятности классов оценивается по формуле <tex>\mathbb{P}\{y|x\} = \sigma\left( y \langle x,w \rangle\right),\;\; y\in Y</tex>.
|proof=

Напомним, что оптимальный байесовский классификатор для двух классов выглядит следущим образом:
<center><tex>a\left(x\right)=
\mathrm{sign}\left(\lambda_+\mathrm{P}\left(+1|x\right)-\lambda_-\mathrm{P}\left(-1|x\right)\right)=
\mathrm{sign}\left(\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)}-\frac{\lambda_-}{\lambda_+}\right)</tex>,</center>

Рассмотрим отношение апостериорных вероятностей классов
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)}</tex>,</center>
и распишем функции правдоподобия, используя экспонентную формулу с параметрами $\theta_y$ и $\delta$:
<center><tex>\frac{\mathrm{P_+}p_+(x)}{\mathrm{P}_-p_-(x)} = \exp\left(\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle+b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-}\right)</tex>,</center>

Рассмотрим получившуюся под экспонентой сумму:
*$\langle\left(c_+(\delta)\theta_+-c_-(\delta)\theta_-\right), x\rangle = \langle w, x\rangle$. Вектор $w$ не зависит от $x$ и является вектором свободных коэффициентов(весов) при константных признаках;
*$b_+(\delta, \theta_+)-b_-(\delta, \theta_-) + \ln\frac{\mathrm{P}_+}{\mathrm{P}_-} = \mathrm{const}\left(x\right)$. Можно считать данные слагаемые аддитивной добавкой к коэффициенту при признаке. Но так как свободные коэффициенты настраиваются по обучающей выборке, вычислять эту добавку не имеет смысла и ее можно включить в $\langle w, x\rangle$.

Таким образом,
<center><tex>\frac{\mathrm{P}\left(+1|x\right)}{\mathrm{P}\left(-1|x\right)} = \mathrm{e}^{\langle w, x\rangle}</tex>,</center>

Разделяющая поверхность в байесовском решающем правиле определяется уравнением
<center><tex>\lambda_- \mathrm{P}\left(-1|x\right) = \lambda_+ \mathrm{P}\left(+1|x\right)</tex>,</center>
которое равносильно
<center><tex>\langle w, x\rangle - \ln\frac{\lambda_-}{\lambda_+} = 0</tex>,</center>

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

Используя [[Формула полной вероятности|формулу полной вероятности]] получаем следующее равенство
<center><tex>\mathrm{P}\left(+1|x\right) + \mathrm{P}\left(-1|x\right) = \sigma\left(+\langle w ,x\rangle\right) + \sigma\left(-\langle w ,x\rangle\right) = 1</tex>,</center>

Откуда следует:
<center><tex>\mathrm{P}\left(y|x\right)=\sigma\left(\langle w, x\rangle y\right), y = \{-1, +1\}</tex>,</center>
Таким образом, второй пункт теоремы доказан.
}}

== Примеры кода ==
=== scikit-learn ===
Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html sklearn.linear_model.'''LogisticRegression'''] имеет несколько параметров, например:
* '''solver''' $-$ алгоритм, использующийся для оптимизации;
* '''multi_class''' $-$ классификация на 2 или много классов.

* Импортируем нужные библиотеки:
'''from''' sklearn.linear_model '''import''' LogisticRegression
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества:
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение:
clf = LogisticRegression(random_state='''0''', solver='lbfgs', multi_class='multinomial')
model = clf.'''fit'''(X_train, y_train)

* Предсказание:
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

=== [[Примеры кода на Scala#Логистическая регрессия|Пример кода на Scala]] ===
===Пример на языке Java===
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);

== См. также ==
* [[Байесовская классификация]][на 28.01.19 не создан]
* [[Линейная регрессия]][на 28.01.19 не создан]
* [[Вариации регрессии]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Источники информации ==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Логистическая регрессия]
* [https://en.wikipedia.org/wiki/Logistic_regression Wikipedia {{---}} Logistic regression]
* [https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html scikit-learn.org {{---}} документация по sklearn.linear_model.LogisticRegression]

[[Категория: Машинное обучение]]

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

2019-04-09T00:04:28Z

91.215.123.110: /* Пример кода для Scikit-learn */

'''Линейная регрессия''' (англ. ''linear regression'') — метод восстановления зависимости одной (объясняемой, зависимой) переменной <tex> y </tex> от другой или нескольких других переменных (факторов, регрессоров, независимых переменных) <tex> x </tex> с линейной функцией зависимости. Данный метод позволяет предсказывать значения зависимой переменной <tex> y </tex> по значениям независимой переменной <tex> x </tex>.

== Задача ==

==== Дано ====

* <tex> f_1(x), \dots ,f_n(x) </tex> — числовые признаки;
* модель многомерной линейной регрессии: <tex> f(x,\alpha) = \sum\limits_{j=1}^n \alpha_j f_j(x) </tex>, где <tex> a \in R^n </tex>;
* обучающая выборка: множество из пар <tex>(x_i, y_i)_{i=1 \dots n}</tex>;
* <tex> x_i </tex> — объекты из множества <tex> X = R^n </tex>;
* <tex> y_i </tex> — объекты из множества <tex> X = R </tex>.

==== Матричные обозначения ====

Перейдем к матричным обозначениям:

<tex>
\underset{l \times n}{F} =
\begin{pmatrix}
f_1(x_1) & \dots & f_n(x_1) \\
\dots & \dots & \dots \\
f_n(x_1) & \dots & f_n(x_l)
\end{pmatrix}
,

\underset{l \times 1}{y} =
\begin{pmatrix}
y_1 \\
\dots \\
y_l
\end{pmatrix},

\underset{n \times 1}{\alpha} =
\begin{pmatrix}
\alpha_1 \\
\dots \\
\alpha_l
\end{pmatrix}

</tex>,

где
* <tex> F </tex> — матрица объектов-признаков, где строки соответствуют объектам а столбцы — признакам;
* <tex> y </tex> — вектор ответов, или целевой вектор;
* <tex> \alpha </tex> — вектор коэффициентов.

==== Постановка задачи ====

В этих трех векторно-матричных обозначениях очень удобно расписать постановку задачи наименьших квадратов:

<tex> Q(\alpha, X^l) = \sum\limits_{i=1}^n (f(x_i, \alpha) - y_i)^2 = || F\alpha - y ||^2 \rightarrow \underset{\alpha}{min} </tex>.

Необходимо найти вектор <tex> \alpha </tex> при известной матрице <tex> F </tex> и известном вектор-столбце <tex> y </tex>.

== Решение ==

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

Запишем необходимые условия минимума в матричном виде:

<tex> \frac{\partial Q }{\partial \alpha } (\alpha) = 2F^T (F\alpha - y) = 0 </tex>.

Отсюда следует нормальная система задачи МНК:

<tex> F^T F \alpha = F^T y </tex>,

где <tex> F^T F — n \times n </tex> матрица.

Мы получили систему уравнений, откуда можем выразить искомый вектор <tex> \alpha </tex>.

==== Решение системы ====
<tex> \alpha^* = (F^T F)^{-1} F^T y = F^+ y </tex>, где <tex> F^+ </tex> — псевдо-обратная матрица.

Значение функционала: <tex> Q(\alpha^*) = ||P_F y - y||^2 </tex>, где <tex> P_F = F F^+ = F (F^T F)^{-1} F^T </tex> — ''проекционная матрица''.

==== Проблемы ====

В случае мультиколлинеарности (столбцы матрицы <tex> F </tex> линейно-зависимы) нам не удастся найти обратную матрицу к <tex> F^T F </tex> (она будет вырождена).

Если же столбцы матрицы <tex> F </tex> почти линейно-зависимы, то у нас возникнет масса вычислительных проблем с обращением этой матрицы.

=== Решение МНК через сингулярное разложение ===

Воспользуемся понятием [[ Сингулярное разложение | сингулярного разложения ]], которое позволяет произвольную прямоугольную матрицу представить в виде произведения трех матриц:

<tex> F = V D U^T </tex>.

Найдем псевдо-обратную матрицу: <tex> F^+ = (U D V^T V D U^T)^{-1} U D V^T = U D^{-1} V^T = \sum\limits_{j=1}^n \frac{ 1 }{ \sqrt{ \lambda_j } } u_j v_j^T </tex>.

Теперь, зная псевдо-обратную матрицу, найдем решение задачи наименьших квадратов: <tex> \alpha^* = F^+ y = U D^{-1} V^T y = \sum\limits_{j=1}^n \frac{ 1 }{ \sqrt{ \lambda_j } } u_j (v_j^T y) </tex>.

Найдем вектор, которым наша линейная модель аппроксимирует целевой вектор <tex> y </tex>: <tex> F \alpha^* = P_F y = (V D U^T) U D^{-1} V^T y = V V^T y = \sum\limits_{j=1}^n v_j (v_j^T y) </tex>.

Квадрат нормы вектора коэффициентов: <tex> || \alpha^* ||^2 = ||D^{-1} V^T y||^2 = \sum\limits_{j=1}^n \frac{ 1 }{ \lambda_j } (v_j^T y)^2 </tex>.

В 3-х из 4-х формул сингулярные числа оказались в знаменателе. Если имеются сингулярные числа приближающиеся к 0, то мы получаем проблему мультиколлинеарности. Близкие к 0 собственные значения или сингулярные числа — показатель того, что среди признаков есть почти линейно-зависимый.

== Проблема мультиколлинеарности и переобучения ==

Если имеются сингулярные числа близкие к 0, то:

* матрица <tex> \sum = F^T F </tex> плохо обусловлена;
* решение становится неустойчивым и неинтерпретируемым, слишком большие коэффициенты <tex> || \alpha_j || </tex> разных знаков;
* возникает переобучение: на обучении <tex> Q( \alpha^*, X^l ) = ||F \alpha^* - y||^2 </tex> мало; на контроле <tex> Q( \alpha^*, X^k ) = ||F' \alpha^* - y'||^2 </tex> велико.

Стратегии устранения мультиколлинеарности и переобучения:

* отбор признаков, то есть выкидываем те признаки, которые могут оказаться линейно-зависимыми: <tex> f_1, \dots, f_n \rightarrow f_{j_1} \dots, f_{j_m}, m \leq n </tex>;
* регуляризация (накладываем дополнительные ограничения на вектор коэффициентов): <tex> || \alpha || \rightarrow min </tex>;
* преобразование признаков, чтобы в новом признаковом пространстве признаков оказалось меньше, но они хорошо восстанавливали бы исходные: <tex> f_1, \dots, f_n \rightarrow g_1 \dots, g_m, m \ll n </tex>.

==Примеры кода==
=== Пример кода для Scikit-learn ===

'''import''' matplotlib.pyplot '''as''' plt
'''from''' sklearn '''import''' datasets, linear_model

# generate dataset
X, y = datasets.make_regression(n_samples=1_000, n_features=1, noise=8, shuffle=True)

# test and train data sizes
train_size = 700
test_size = 300

# split the data into training/testing sets
X_train = X[:-train_size]
X_test = X[-test_size:]

# split the targets into training/testing sets
y_train = y[:-train_size]
y_test = y[-test_size:]

# create linear regression object
regr = linear_model.LinearRegression()

# train the model using the training sets
regr.fit(X_train, y_train)

# make predictions using the testing set
y_pred = regr.predict(X_test)

# plot outputs
plt.scatter(X_test, y_test, color='red', s=5)
plt.plot(X_test, y_pred, color='blue', linewidth=2)

plt.xticks(())
plt.yticks(())

plt.show()

Возможный результат исполнения программы:

[[Файл: Linear_regression_example.png]]

===Пример на языке Java===
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<code>Maven</code> зависимомсть:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)

==Применение==

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

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

==См. также==

* [[Общие понятия]]
* [[Вариации регрессии]]
* [[Логистическая регрессия]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Переобучение]]

==Источники информации==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%BD%D0%BE%D0%B3%D0%BE%D0%BC%D0%B5%D1%80%D0%BD%D0%B0%D1%8F_%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Многомерная линейная регрессия]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 machinelearning.ru {{---}} Линейная регрессия (пример)]
* [https://www.coursera.org/learn/vvedenie-mashinnoe-obuchenie/home/info Coursera {{---}} "Введение в машинное обучение", Неделя 4, ]
* [http://www.ccas.ru/voron/download/Regression.pdf Лекции по алгоритмам восстановления регрессии К. В. Воронцов]
* [https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py Scikit-Learn {{---}} Linear Regression Example]
* [https://www.quora.com/What-are-some-real-world-applications-of-simple-linear-regression What are some real-world applications of "simple" linear regression?]

[[Категория: Машинное обучение]]
[[Категория: Регрессия]]

Примеры кода на Java

2019-04-09T00:02:46Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Пример на языке Java}}
====Лассо-регрессия====
{{Main|Вариации регрессии#Пример на языке Java_2}}

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)#Пример на языке Java}}
===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Вариации регрессии

2019-04-08T23:59:41Z

91.215.123.110: /* Лассо-регрессия */

'''Регрессия''' (англ. ''Regression'') {{---}} метод моделирования зависимости между зависимой переменной <tex>y</tex> и одной или несколькими независимыми переменными <tex>x_1, x_2, \dots, x_n</tex>. В случае нескольких независимых переменных регрессия называется '''множественной''' (англ. ''multivariate regression''). Цель регрессионного анализа состоит в том, чтобы оценить значение непрерывной выходной переменной по значениям входных переменных.

==Линейная регрессия==
{{main|Линейная регрессия}}

'''Линейная регрессия''' (англ. ''linear regression'') {{---}} разновидность регрессии для моделирования линейной зависимости между зависимой и независимой переменными.

==Логистическая регрессия==
{{main|Логистическая регрессия}}
'''Логистическая регрессия''' (англ. ''logistic regression'') {{---}} разновидность регрессии для прогнозирования вероятности некоторого события по значениям независимых переменных. Зависимая переменная <tex>y</tex> в этом случае принимает значения <tex>0</tex> или <tex>1</tex> (рассматриваемое событие не произошло или произошло соответственно).

==Гребневая регрессия (ридж-регрессия)==
'''Гребневая регрессия или ридж-регрессия''' (англ. ''ridge regression'') {{---}} один из методов [[Уменьшение размерности|понижения размерности]]. Применяется для борьбы с избыточностью данных, когда независимые переменные коррелируют друг с другом, вследствие чего проявляется неустойчивость оценок коэффициентов многомерной линейной регрессии.

===Мотивация===
{{Определение
|definition =
'''Мультиколлинеарность''' (англ. ''multicollinearity'') {{---}} наличие линейной зависимости между независимыми переменными регрессионной модели. Различают ''полную коллинеарность'' и ''частичную'' или просто ''мультиколлинеарность'' {{---}} наличие сильной корреляции между независимыми переменными.
}}
Рассмотрим пример линейной модели: <tex>y = b_1 x_1 + b_2 x_2 + b_3 x_3 + \varepsilon</tex>.
Пусть имеет место зависимость <tex>x_1 = x_2 + x_ 3</tex>. Добавим к первому коэффициенту произвольное число <tex>a</tex>, а из двух других коэффициентов это же число вычтем.
Получаем (без случайной ошибки):
:<tex>y = (b_1 + a)x_1 + (b_2 - a)x_2 + (b_3 - a)x_3 = b_1 x_1 + b_2 x_2 + b_3 x_3 + a(x_1 - x_2 - x_3) = b_1 x_1 + b_2 x_2 + b_3 x_3</tex>

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

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

===Описание===
Напомним задачу многомерной линейной регрессии:

Рассматривается линейная зависимость <tex>f(x, \beta) = \langle \beta, x \rangle</tex>.

Находим вектор <tex>\beta^*</tex>, при котором достигается минимум среднего квадрата ошибки:
:<tex>Q(\beta) = ||F \beta - y||^2</tex>

:<tex>\beta^*=\arg \min\limits_\beta Q(\beta)</tex>

Методом наименьших квадратов находим решение:
:<tex>\beta^* = (F^T F)^{-1} F^T y</tex>

В условиях мультиколлинеарности матрица <tex>F^T F</tex> становится плохо обусловленной.

Для решения этой проблемы наложим ограничение на величину коэффициентов <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_2^2 \leq t^2</tex>.

Функционал <tex>Q</tex> с учетом ограничения принимает вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||^2</tex>,
где <tex>\lambda</tex> {{---}} неотрицательный параметр.

Решением в этом случае будет
:<tex>\beta^* = (F^T F + \lambda I_n)^{-1} F^T y</tex>

Это изменение увеличивает собственные значения матрицы <tex>F^T F</tex>, но не изменяет ее собственные вектора. В результате имеем хорошо обусловленную матрицу.

Диагональная матрица <tex>\lambda I_n</tex> называется '''гребнем'''.

===Примеры кода===
====Пример кода для Scikit-learn====
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Ridge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

ridge_regression = Ridge(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
ridge_regression.fit(train_X, train_y)

# предсказание результата
''print''(ridge_regression.predict(test_X))

# вывод точности предсказания
''print''(ridge_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8171822749108134

====Пример на языке Java====
Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);

==Лассо-регрессия==
[[Файл: Ridge_and_Lasso_Regression.png|400px|thumb|Рис.1. Сравнение Лассо- и Ридж- регрессии, пример для двумерного пространства независимых переменных. Бирюзовые области изображают ограничения на коэффициенты <tex>\beta</tex>, эллипсы {{---}} некоторые значения функции наименьшей квадратичной ошибки.]]

'''Метод регрессии лассо''' (англ. ''LASSO, Least Absolute Shrinkage and Selection Operator'') похож на гребневую регрессию, но он использует другое ограничение на коэффициенты <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_1 \leq t</tex>

Функционал <tex>Q</tex> принимает следующий вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||</tex>

Основное различие лассо- и ридж-регрессии заключается в том, что первая может приводить к обращению некоторых независимых переменных в ноль, тогда как вторая уменьшает их до значений, близких к нулю. Рассмотрим для простоты двумерное пространство независимых переменных. В случае лассо-регрессии органичение на коэффициенты представляет собой ромб (<tex>|\beta_1| + |\beta_2| \leq t</tex>), в случае ридж-регрессии {{---}} круг (<tex>\beta_1^2 + \beta_2^2 \leq t^2</tex>). Необходимо минимизировать функцию ошибки, но при этом соблюсти ограничения на коэффициенты. С геометрической точки зрения задача состоит в том, чтобы найти точку касания линии, отражающей функцию ошибки с фигурой, отражающей ограничения на <tex>\beta</tex>. Из рисунка 1 интуитивно понятно, что в случае лассо-регрессии эта точка с большой вероятностью будет находиться на углах ромба, то есть лежать на оси, тогда как в случае ридж-регрессии такое происходит очень редко. Если точка пересечения лежит на оси, один из коэффициентов будет равен нулю, а значит, значение соответствующей независимой переменной не будет учитываться.

===Примеры кода===
====Пример кода для Scikit-learn====
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Lasso
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

lasso_regression = Lasso(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
lasso_regression.fit(train_X, train_y)

# предсказание результата
''print''(lasso_regression.predict(test_X))

# вывод точности предсказания
''print''(lasso_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8173906804156383

====Пример на языке Java====

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);

==Байесовская регрессия==
Описанные выше методы никак не учитывали наличие в данных шума, тогда как в реальных данных он скорее всего будет присутствовать. Предположим, что в данных все же есть некоторый шум, и что он распределен нормально. Тогда задачу линейной регрессии можно записать в следующем виде:
:<tex>f(x, \beta) = \langle \beta, x \rangle + \varepsilon</tex>, где <tex>\varepsilon \sim N(0, \sigma^2)</tex>.

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

[[Файл: Bayessian_regression_noise.jpg|250px|thumb|Рис.2. Регрессия и шум в данных. Синяя точка {{---}} значение из датасета, красная {{---}} значение, полученное в результате работы алгоритма регрессии. Также на рисунке зеленой линией изображена предсказанная функция, а черной {{---}} гауссово распределение шума.]]

'''Байесовская линейная регрессия''' (англ. ''Bayesian linear regression'') {{---}} подход в линейной регрессии, в котором предполагается что шум распределен нормально.

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

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

Запишем правдоподобие:
:<tex>p(y|x, \beta, \sigma^2) = N(x \beta, \sigma^2)</tex>,
где <tex>p(y|x, \beta, \sigma^2)</tex> {{---}} плотность распределения значения <tex>y</tex> из датасета, которая, как мы ранее предположили, соответствует нормальному распределению с центром в точке <tex>x \beta</tex> (значение для <tex>y</tex>, предсказанное алгоритмом).

Будем также предполагать, что данные независимы:
:<tex>p(y|x, \beta, \sigma^2) = \prod\limits_{i=1}^n N(x_i \beta, \sigma^2)</tex>

Поскольку нас интересует только максимум, положим <tex>\sigma = 1</tex>:
:<tex>\arg\max p(y|x, \beta) = \arg\max \prod\limits_{i=1}^n N(x_i \beta, 1)</tex>

Прологарифмируем это выражение:
:<tex>\arg\max \ln p(y|x, \beta) = \arg\max \ln \prod\limits_{i=1}^n N(x_i \beta, 1) \\
= \arg\max \ln {\left( \frac{1}{(\sqrt{2 \pi})^n} \exp{\left(-\frac{1}{2} \sum\limits_{i-1}^n (y_i - x_i \beta)^2\right)}\right )} \\
= \arg\max - \sum\limits_{i=1}^n (y_i - x_i \beta)^2 \\
= \arg\min \sum\limits_{i=1}^n (y_i - x_i \beta)^2</tex>

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

===Пример кода для Scikit-learn===
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' BayesianRidge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

bayesian_regression = BayesianRidge()

# обучение
bayesian_regression.fit(train_X, train_y)

# предсказание результата
''print''(bayesian_regression.predict(test_X))

# вывод точности предсказания
''print''(bayesian_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8170548749907206

==Логическая регрессия==
'''Логическая регрессия''' (англ. ''logic regression'') {{---}} обобщенный метод регрессии, применяемый в основном в случае, когда независимые переменные имеют двоичную природу (при этом зависимая переменная не обязательно двоичная). Задачей логической регрессии является определение независимых переменных, которые могут быть выражены как результат вычисления [[Определение булевой функции|булевой функции]] от других независимых переменных.

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

Пусть <tex>x_1, x_2, \dots, x_k</tex> {{---}} двоичные независимые переменные, и пусть <tex>y</tex> {{---}} зависимая переменная. Будем пытаться натренировать модели регрессии вида <tex>g(E(y)) = b_0 + b_1 L_1 + \dots + b_n L_n</tex>, где <tex>L_j</tex> {{---}} булева функция от переменных <tex>x_i</tex> (например <tex>L_j = (x_2 \lor \overline{x_4}) \land x_7</tex>).
Для каждого типа модели необходимо определить функцию, которая отражает качество рассматриваемой модели. Например, для линейной регрессии такой функцией может быть остаточная сумма квадратов. Целью метода логической регрессии является минимизация выбранной функции качества посредством настройки параметров <tex>b_j</tex> одновременно с булевыми выражениями <tex>L_j</tex>.

[[Файл: Logic_tree_moves.jpg|400px|thumb|Рис.3. Допустимые действия в процессе роста дерева. Элементы, появившиеся в результате применения операции, выделены черным фоном.]]

Может показаться не совсем понятным, как же применить регрессию к булевым выражениям. Рассмотрим в общих чертах алгоритм логической регрессии.
Логическая регрессия, как и другие методы регрессии, перебирает различные выражения в попытках минимизировать функцию потерь. Для <tex>k</tex> переменных можно составить <tex>2^{2^k}</tex> различных выражений. Нужно найти более эффективный метод для поиска наилучшего выражения, чем простой перебор всех вариантов.

Любое логическое выражение можно представить в виде дерева, где в узлах расположены операции, а листья представляют собой переменные. Будем называть такие деревья '''логическими деревьями''' (англ. ''logic trees''). Будем называть '''соседями''' (англ. ''neighbours'') логического дерева такие деревья, которые могут быть получены из него за один шаг. Допустимые шаги проиллюстрированы на рисунке 3.

Рассмотрим самый простой алгоритм поиска наилучшего дерева {{---}} '''жадный поиск''' (англ. ''greedy search'').
# В качестве стартового дерева выберем одну переменную, которая дает минимальное значение функции потерь среди всех остальных переменных.
# Перебираем соседей текущего дерева и выбираем такое, что оно уменьшает значение функции потерь по сравнению с текущим, а также дает наименьший результат среди остальных соседей.
# Если такого дерева не существует, алгоритм завершается. Если оно все же есть, выбираем его в качестве текущего и повторяем второй шаг.

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

==См. также==
* [[Общие понятия]]
* [[Линейная регрессия]]
* [[Логистическая регрессия]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Байесовская классификация]]
* [[Уменьшение размерности]]

==Источники информации==
* [http://datareview.info/article/10-tipov-regressii-kakoy-vyibrat/ 10 типов регрессии {{---}} какой выбрать?]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 machinelearning.ru {{---}} Линейная регрессия (пример)]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%A0%D0%B8%D0%B4%D0%B6-%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Ридж-регрессия]
* [http://www.ccas.ru/voron/download/Regression.pdf Лекции по алгоритмам восстановления регрессии К. В. Воронцов]
* [https://towardsdatascience.com/ridge-and-lasso-regression-a-complete-guide-with-python-scikit-learn-e20e34bcbf0b Ridge and Lasso Regression: A Complete Guide with Python Scikit-Learn]
* [https://habr.com/ru/company/ods/blog/322076/ Habr {{---}} Базовые принципы машинного обучения на примере линейной регрессии]
* [http://kooperberg.fhcrc.org/logic/documents/documents.html Documents on Logic Regression]

[[Категория: Машинное обучение]]
[[Категория: Регрессия]]

Вариации регрессии

2019-04-08T23:55:58Z

91.215.123.110: /* Пример на языке Java= */

'''Регрессия''' (англ. ''Regression'') {{---}} метод моделирования зависимости между зависимой переменной <tex>y</tex> и одной или несколькими независимыми переменными <tex>x_1, x_2, \dots, x_n</tex>. В случае нескольких независимых переменных регрессия называется '''множественной''' (англ. ''multivariate regression''). Цель регрессионного анализа состоит в том, чтобы оценить значение непрерывной выходной переменной по значениям входных переменных.

==Линейная регрессия==
{{main|Линейная регрессия}}

'''Линейная регрессия''' (англ. ''linear regression'') {{---}} разновидность регрессии для моделирования линейной зависимости между зависимой и независимой переменными.

==Логистическая регрессия==
{{main|Логистическая регрессия}}
'''Логистическая регрессия''' (англ. ''logistic regression'') {{---}} разновидность регрессии для прогнозирования вероятности некоторого события по значениям независимых переменных. Зависимая переменная <tex>y</tex> в этом случае принимает значения <tex>0</tex> или <tex>1</tex> (рассматриваемое событие не произошло или произошло соответственно).

==Гребневая регрессия (ридж-регрессия)==
'''Гребневая регрессия или ридж-регрессия''' (англ. ''ridge regression'') {{---}} один из методов [[Уменьшение размерности|понижения размерности]]. Применяется для борьбы с избыточностью данных, когда независимые переменные коррелируют друг с другом, вследствие чего проявляется неустойчивость оценок коэффициентов многомерной линейной регрессии.

===Мотивация===
{{Определение
|definition =
'''Мультиколлинеарность''' (англ. ''multicollinearity'') {{---}} наличие линейной зависимости между независимыми переменными регрессионной модели. Различают ''полную коллинеарность'' и ''частичную'' или просто ''мультиколлинеарность'' {{---}} наличие сильной корреляции между независимыми переменными.
}}
Рассмотрим пример линейной модели: <tex>y = b_1 x_1 + b_2 x_2 + b_3 x_3 + \varepsilon</tex>.
Пусть имеет место зависимость <tex>x_1 = x_2 + x_ 3</tex>. Добавим к первому коэффициенту произвольное число <tex>a</tex>, а из двух других коэффициентов это же число вычтем.
Получаем (без случайной ошибки):
:<tex>y = (b_1 + a)x_1 + (b_2 - a)x_2 + (b_3 - a)x_3 = b_1 x_1 + b_2 x_2 + b_3 x_3 + a(x_1 - x_2 - x_3) = b_1 x_1 + b_2 x_2 + b_3 x_3</tex>

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

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

===Описание===
Напомним задачу многомерной линейной регрессии:

Рассматривается линейная зависимость <tex>f(x, \beta) = \langle \beta, x \rangle</tex>.

Находим вектор <tex>\beta^*</tex>, при котором достигается минимум среднего квадрата ошибки:
:<tex>Q(\beta) = ||F \beta - y||^2</tex>

:<tex>\beta^*=\arg \min\limits_\beta Q(\beta)</tex>

Методом наименьших квадратов находим решение:
:<tex>\beta^* = (F^T F)^{-1} F^T y</tex>

В условиях мультиколлинеарности матрица <tex>F^T F</tex> становится плохо обусловленной.

Для решения этой проблемы наложим ограничение на величину коэффициентов <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_2^2 \leq t^2</tex>.

Функционал <tex>Q</tex> с учетом ограничения принимает вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||^2</tex>,
где <tex>\lambda</tex> {{---}} неотрицательный параметр.

Решением в этом случае будет
:<tex>\beta^* = (F^T F + \lambda I_n)^{-1} F^T y</tex>

Это изменение увеличивает собственные значения матрицы <tex>F^T F</tex>, но не изменяет ее собственные вектора. В результате имеем хорошо обусловленную матрицу.

Диагональная матрица <tex>\lambda I_n</tex> называется '''гребнем'''.

===Примеры кода===
====Пример кода для Scikit-learn====
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Ridge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

ridge_regression = Ridge(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
ridge_regression.fit(train_X, train_y)

# предсказание результата
''print''(ridge_regression.predict(test_X))

# вывод точности предсказания
''print''(ridge_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8171822749108134

====Пример на языке Java====
Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);

==Лассо-регрессия==
[[Файл: Ridge_and_Lasso_Regression.png|400px|thumb|Рис.1. Сравнение Лассо- и Ридж- регрессии, пример для двумерного пространства независимых переменных. Бирюзовые области изображают ограничения на коэффициенты <tex>\beta</tex>, эллипсы {{---}} некоторые значения функции наименьшей квадратичной ошибки.]]

'''Метод регрессии лассо''' (англ. ''LASSO, Least Absolute Shrinkage and Selection Operator'') похож на гребневую регрессию, но он использует другое ограничение на коэффициенты <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_1 \leq t</tex>

Функционал <tex>Q</tex> принимает следующий вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||</tex>

Основное различие лассо- и ридж-регрессии заключается в том, что первая может приводить к обращению некоторых независимых переменных в ноль, тогда как вторая уменьшает их до значений, близких к нулю. Рассмотрим для простоты двумерное пространство независимых переменных. В случае лассо-регрессии органичение на коэффициенты представляет собой ромб (<tex>|\beta_1| + |\beta_2| \leq t</tex>), в случае ридж-регрессии {{---}} круг (<tex>\beta_1^2 + \beta_2^2 \leq t^2</tex>). Необходимо минимизировать функцию ошибки, но при этом соблюсти ограничения на коэффициенты. С геометрической точки зрения задача состоит в том, чтобы найти точку касания линии, отражающей функцию ошибки с фигурой, отражающей ограничения на <tex>\beta</tex>. Из рисунка 1 интуитивно понятно, что в случае лассо-регрессии эта точка с большой вероятностью будет находиться на углах ромба, то есть лежать на оси, тогда как в случае ридж-регрессии такое происходит очень редко. Если точка пересечения лежит на оси, один из коэффициентов будет равен нулю, а значит, значение соответствующей независимой переменной не будет учитываться.

===Пример кода для Scikit-learn===
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Lasso
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

lasso_regression = Lasso(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
lasso_regression.fit(train_X, train_y)

# предсказание результата
''print''(lasso_regression.predict(test_X))

# вывод точности предсказания
''print''(lasso_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8173906804156383

==Байесовская регрессия==
Описанные выше методы никак не учитывали наличие в данных шума, тогда как в реальных данных он скорее всего будет присутствовать. Предположим, что в данных все же есть некоторый шум, и что он распределен нормально. Тогда задачу линейной регрессии можно записать в следующем виде:
:<tex>f(x, \beta) = \langle \beta, x \rangle + \varepsilon</tex>, где <tex>\varepsilon \sim N(0, \sigma^2)</tex>.

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

[[Файл: Bayessian_regression_noise.jpg|250px|thumb|Рис.2. Регрессия и шум в данных. Синяя точка {{---}} значение из датасета, красная {{---}} значение, полученное в результате работы алгоритма регрессии. Также на рисунке зеленой линией изображена предсказанная функция, а черной {{---}} гауссово распределение шума.]]

'''Байесовская линейная регрессия''' (англ. ''Bayesian linear regression'') {{---}} подход в линейной регрессии, в котором предполагается что шум распределен нормально.

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

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

Запишем правдоподобие:
:<tex>p(y|x, \beta, \sigma^2) = N(x \beta, \sigma^2)</tex>,
где <tex>p(y|x, \beta, \sigma^2)</tex> {{---}} плотность распределения значения <tex>y</tex> из датасета, которая, как мы ранее предположили, соответствует нормальному распределению с центром в точке <tex>x \beta</tex> (значение для <tex>y</tex>, предсказанное алгоритмом).

Будем также предполагать, что данные независимы:
:<tex>p(y|x, \beta, \sigma^2) = \prod\limits_{i=1}^n N(x_i \beta, \sigma^2)</tex>

Поскольку нас интересует только максимум, положим <tex>\sigma = 1</tex>:
:<tex>\arg\max p(y|x, \beta) = \arg\max \prod\limits_{i=1}^n N(x_i \beta, 1)</tex>

Прологарифмируем это выражение:
:<tex>\arg\max \ln p(y|x, \beta) = \arg\max \ln \prod\limits_{i=1}^n N(x_i \beta, 1) \\
= \arg\max \ln {\left( \frac{1}{(\sqrt{2 \pi})^n} \exp{\left(-\frac{1}{2} \sum\limits_{i-1}^n (y_i - x_i \beta)^2\right)}\right )} \\
= \arg\max - \sum\limits_{i=1}^n (y_i - x_i \beta)^2 \\
= \arg\min \sum\limits_{i=1}^n (y_i - x_i \beta)^2</tex>

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

===Пример кода для Scikit-learn===
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' BayesianRidge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

bayesian_regression = BayesianRidge()

# обучение
bayesian_regression.fit(train_X, train_y)

# предсказание результата
''print''(bayesian_regression.predict(test_X))

# вывод точности предсказания
''print''(bayesian_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8170548749907206

==Логическая регрессия==
'''Логическая регрессия''' (англ. ''logic regression'') {{---}} обобщенный метод регрессии, применяемый в основном в случае, когда независимые переменные имеют двоичную природу (при этом зависимая переменная не обязательно двоичная). Задачей логической регрессии является определение независимых переменных, которые могут быть выражены как результат вычисления [[Определение булевой функции|булевой функции]] от других независимых переменных.

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

Пусть <tex>x_1, x_2, \dots, x_k</tex> {{---}} двоичные независимые переменные, и пусть <tex>y</tex> {{---}} зависимая переменная. Будем пытаться натренировать модели регрессии вида <tex>g(E(y)) = b_0 + b_1 L_1 + \dots + b_n L_n</tex>, где <tex>L_j</tex> {{---}} булева функция от переменных <tex>x_i</tex> (например <tex>L_j = (x_2 \lor \overline{x_4}) \land x_7</tex>).
Для каждого типа модели необходимо определить функцию, которая отражает качество рассматриваемой модели. Например, для линейной регрессии такой функцией может быть остаточная сумма квадратов. Целью метода логической регрессии является минимизация выбранной функции качества посредством настройки параметров <tex>b_j</tex> одновременно с булевыми выражениями <tex>L_j</tex>.

[[Файл: Logic_tree_moves.jpg|400px|thumb|Рис.3. Допустимые действия в процессе роста дерева. Элементы, появившиеся в результате применения операции, выделены черным фоном.]]

Может показаться не совсем понятным, как же применить регрессию к булевым выражениям. Рассмотрим в общих чертах алгоритм логической регрессии.
Логическая регрессия, как и другие методы регрессии, перебирает различные выражения в попытках минимизировать функцию потерь. Для <tex>k</tex> переменных можно составить <tex>2^{2^k}</tex> различных выражений. Нужно найти более эффективный метод для поиска наилучшего выражения, чем простой перебор всех вариантов.

Любое логическое выражение можно представить в виде дерева, где в узлах расположены операции, а листья представляют собой переменные. Будем называть такие деревья '''логическими деревьями''' (англ. ''logic trees''). Будем называть '''соседями''' (англ. ''neighbours'') логического дерева такие деревья, которые могут быть получены из него за один шаг. Допустимые шаги проиллюстрированы на рисунке 3.

Рассмотрим самый простой алгоритм поиска наилучшего дерева {{---}} '''жадный поиск''' (англ. ''greedy search'').
# В качестве стартового дерева выберем одну переменную, которая дает минимальное значение функции потерь среди всех остальных переменных.
# Перебираем соседей текущего дерева и выбираем такое, что оно уменьшает значение функции потерь по сравнению с текущим, а также дает наименьший результат среди остальных соседей.
# Если такого дерева не существует, алгоритм завершается. Если оно все же есть, выбираем его в качестве текущего и повторяем второй шаг.

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

==См. также==
* [[Общие понятия]]
* [[Линейная регрессия]]
* [[Логистическая регрессия]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Байесовская классификация]]
* [[Уменьшение размерности]]

==Источники информации==
* [http://datareview.info/article/10-tipov-regressii-kakoy-vyibrat/ 10 типов регрессии {{---}} какой выбрать?]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 machinelearning.ru {{---}} Линейная регрессия (пример)]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%A0%D0%B8%D0%B4%D0%B6-%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Ридж-регрессия]
* [http://www.ccas.ru/voron/download/Regression.pdf Лекции по алгоритмам восстановления регрессии К. В. Воронцов]
* [https://towardsdatascience.com/ridge-and-lasso-regression-a-complete-guide-with-python-scikit-learn-e20e34bcbf0b Ridge and Lasso Regression: A Complete Guide with Python Scikit-Learn]
* [https://habr.com/ru/company/ods/blog/322076/ Habr {{---}} Базовые принципы машинного обучения на примере линейной регрессии]
* [http://kooperberg.fhcrc.org/logic/documents/documents.html Documents on Logic Regression]

[[Категория: Машинное обучение]]
[[Категория: Регрессия]]

Вариации регрессии

2019-04-08T23:55:27Z

91.215.123.110:

'''Регрессия''' (англ. ''Regression'') {{---}} метод моделирования зависимости между зависимой переменной <tex>y</tex> и одной или несколькими независимыми переменными <tex>x_1, x_2, \dots, x_n</tex>. В случае нескольких независимых переменных регрессия называется '''множественной''' (англ. ''multivariate regression''). Цель регрессионного анализа состоит в том, чтобы оценить значение непрерывной выходной переменной по значениям входных переменных.

==Линейная регрессия==
{{main|Линейная регрессия}}

'''Линейная регрессия''' (англ. ''linear regression'') {{---}} разновидность регрессии для моделирования линейной зависимости между зависимой и независимой переменными.

==Логистическая регрессия==
{{main|Логистическая регрессия}}
'''Логистическая регрессия''' (англ. ''logistic regression'') {{---}} разновидность регрессии для прогнозирования вероятности некоторого события по значениям независимых переменных. Зависимая переменная <tex>y</tex> в этом случае принимает значения <tex>0</tex> или <tex>1</tex> (рассматриваемое событие не произошло или произошло соответственно).

==Гребневая регрессия (ридж-регрессия)==
'''Гребневая регрессия или ридж-регрессия''' (англ. ''ridge regression'') {{---}} один из методов [[Уменьшение размерности|понижения размерности]]. Применяется для борьбы с избыточностью данных, когда независимые переменные коррелируют друг с другом, вследствие чего проявляется неустойчивость оценок коэффициентов многомерной линейной регрессии.

===Мотивация===
{{Определение
|definition =
'''Мультиколлинеарность''' (англ. ''multicollinearity'') {{---}} наличие линейной зависимости между независимыми переменными регрессионной модели. Различают ''полную коллинеарность'' и ''частичную'' или просто ''мультиколлинеарность'' {{---}} наличие сильной корреляции между независимыми переменными.
}}
Рассмотрим пример линейной модели: <tex>y = b_1 x_1 + b_2 x_2 + b_3 x_3 + \varepsilon</tex>.
Пусть имеет место зависимость <tex>x_1 = x_2 + x_ 3</tex>. Добавим к первому коэффициенту произвольное число <tex>a</tex>, а из двух других коэффициентов это же число вычтем.
Получаем (без случайной ошибки):
:<tex>y = (b_1 + a)x_1 + (b_2 - a)x_2 + (b_3 - a)x_3 = b_1 x_1 + b_2 x_2 + b_3 x_3 + a(x_1 - x_2 - x_3) = b_1 x_1 + b_2 x_2 + b_3 x_3</tex>

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

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

===Описание===
Напомним задачу многомерной линейной регрессии:

Рассматривается линейная зависимость <tex>f(x, \beta) = \langle \beta, x \rangle</tex>.

Находим вектор <tex>\beta^*</tex>, при котором достигается минимум среднего квадрата ошибки:
:<tex>Q(\beta) = ||F \beta - y||^2</tex>

:<tex>\beta^*=\arg \min\limits_\beta Q(\beta)</tex>

Методом наименьших квадратов находим решение:
:<tex>\beta^* = (F^T F)^{-1} F^T y</tex>

В условиях мультиколлинеарности матрица <tex>F^T F</tex> становится плохо обусловленной.

Для решения этой проблемы наложим ограничение на величину коэффициентов <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_2^2 \leq t^2</tex>.

Функционал <tex>Q</tex> с учетом ограничения принимает вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||^2</tex>,
где <tex>\lambda</tex> {{---}} неотрицательный параметр.

Решением в этом случае будет
:<tex>\beta^* = (F^T F + \lambda I_n)^{-1} F^T y</tex>

Это изменение увеличивает собственные значения матрицы <tex>F^T F</tex>, но не изменяет ее собственные вектора. В результате имеем хорошо обусловленную матрицу.

Диагональная матрица <tex>\lambda I_n</tex> называется '''гребнем'''.

===Примеры кода===
====Пример кода для Scikit-learn====
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Ridge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

ridge_regression = Ridge(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
ridge_regression.fit(train_X, train_y)

# предсказание результата
''print''(ridge_regression.predict(test_X))

# вывод точности предсказания
''print''(ridge_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8171822749108134

====Пример на языке Java=====
Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);

==Лассо-регрессия==
[[Файл: Ridge_and_Lasso_Regression.png|400px|thumb|Рис.1. Сравнение Лассо- и Ридж- регрессии, пример для двумерного пространства независимых переменных. Бирюзовые области изображают ограничения на коэффициенты <tex>\beta</tex>, эллипсы {{---}} некоторые значения функции наименьшей квадратичной ошибки.]]

'''Метод регрессии лассо''' (англ. ''LASSO, Least Absolute Shrinkage and Selection Operator'') похож на гребневую регрессию, но он использует другое ограничение на коэффициенты <tex>\beta</tex>: <tex>||\overrightarrow{\beta}||_1 \leq t</tex>

Функционал <tex>Q</tex> принимает следующий вид:
:<tex>Q_{\lambda}(\beta) = ||F \beta - y||^2 + \lambda ||\beta||</tex>

Основное различие лассо- и ридж-регрессии заключается в том, что первая может приводить к обращению некоторых независимых переменных в ноль, тогда как вторая уменьшает их до значений, близких к нулю. Рассмотрим для простоты двумерное пространство независимых переменных. В случае лассо-регрессии органичение на коэффициенты представляет собой ромб (<tex>|\beta_1| + |\beta_2| \leq t</tex>), в случае ридж-регрессии {{---}} круг (<tex>\beta_1^2 + \beta_2^2 \leq t^2</tex>). Необходимо минимизировать функцию ошибки, но при этом соблюсти ограничения на коэффициенты. С геометрической точки зрения задача состоит в том, чтобы найти точку касания линии, отражающей функцию ошибки с фигурой, отражающей ограничения на <tex>\beta</tex>. Из рисунка 1 интуитивно понятно, что в случае лассо-регрессии эта точка с большой вероятностью будет находиться на углах ромба, то есть лежать на оси, тогда как в случае ридж-регрессии такое происходит очень редко. Если точка пересечения лежит на оси, один из коэффициентов будет равен нулю, а значит, значение соответствующей независимой переменной не будет учитываться.

===Пример кода для Scikit-learn===
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' Lasso
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

lasso_regression = Lasso(alpha=0.1) # alpha {{---}} величина регуляризации

# обучение
lasso_regression.fit(train_X, train_y)

# предсказание результата
''print''(lasso_regression.predict(test_X))

# вывод точности предсказания
''print''(lasso_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8173906804156383

==Байесовская регрессия==
Описанные выше методы никак не учитывали наличие в данных шума, тогда как в реальных данных он скорее всего будет присутствовать. Предположим, что в данных все же есть некоторый шум, и что он распределен нормально. Тогда задачу линейной регрессии можно записать в следующем виде:
:<tex>f(x, \beta) = \langle \beta, x \rangle + \varepsilon</tex>, где <tex>\varepsilon \sim N(0, \sigma^2)</tex>.

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

[[Файл: Bayessian_regression_noise.jpg|250px|thumb|Рис.2. Регрессия и шум в данных. Синяя точка {{---}} значение из датасета, красная {{---}} значение, полученное в результате работы алгоритма регрессии. Также на рисунке зеленой линией изображена предсказанная функция, а черной {{---}} гауссово распределение шума.]]

'''Байесовская линейная регрессия''' (англ. ''Bayesian linear regression'') {{---}} подход в линейной регрессии, в котором предполагается что шум распределен нормально.

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

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

Запишем правдоподобие:
:<tex>p(y|x, \beta, \sigma^2) = N(x \beta, \sigma^2)</tex>,
где <tex>p(y|x, \beta, \sigma^2)</tex> {{---}} плотность распределения значения <tex>y</tex> из датасета, которая, как мы ранее предположили, соответствует нормальному распределению с центром в точке <tex>x \beta</tex> (значение для <tex>y</tex>, предсказанное алгоритмом).

Будем также предполагать, что данные независимы:
:<tex>p(y|x, \beta, \sigma^2) = \prod\limits_{i=1}^n N(x_i \beta, \sigma^2)</tex>

Поскольку нас интересует только максимум, положим <tex>\sigma = 1</tex>:
:<tex>\arg\max p(y|x, \beta) = \arg\max \prod\limits_{i=1}^n N(x_i \beta, 1)</tex>

Прологарифмируем это выражение:
:<tex>\arg\max \ln p(y|x, \beta) = \arg\max \ln \prod\limits_{i=1}^n N(x_i \beta, 1) \\
= \arg\max \ln {\left( \frac{1}{(\sqrt{2 \pi})^n} \exp{\left(-\frac{1}{2} \sum\limits_{i-1}^n (y_i - x_i \beta)^2\right)}\right )} \\
= \arg\max - \sum\limits_{i=1}^n (y_i - x_i \beta)^2 \\
= \arg\min \sum\limits_{i=1}^n (y_i - x_i \beta)^2</tex>

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

===Пример кода для Scikit-learn===
# импорт библиотек
'''from''' sklearn.datasets '''import''' make_regression
'''from''' sklearn.linear_model '''import''' BayesianRidge
'''from''' sklearn.model_selection '''import''' train_test_split

# генерируем данные для X и y
X, y = make_regression(n_samples=10000, noise=100, random_state=0)

# разделение данных на train и test
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3, random_state=3)

bayesian_regression = BayesianRidge()

# обучение
bayesian_regression.fit(train_X, train_y)

# предсказание результата
''print''(bayesian_regression.predict(test_X))

# вывод точности предсказания
''print''(bayesian_regression.score(test_X, test_y))

Точность предсказания для данного датасета и параметров:
>>> 0.8170548749907206

==Логическая регрессия==
'''Логическая регрессия''' (англ. ''logic regression'') {{---}} обобщенный метод регрессии, применяемый в основном в случае, когда независимые переменные имеют двоичную природу (при этом зависимая переменная не обязательно двоичная). Задачей логической регрессии является определение независимых переменных, которые могут быть выражены как результат вычисления [[Определение булевой функции|булевой функции]] от других независимых переменных.

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

Пусть <tex>x_1, x_2, \dots, x_k</tex> {{---}} двоичные независимые переменные, и пусть <tex>y</tex> {{---}} зависимая переменная. Будем пытаться натренировать модели регрессии вида <tex>g(E(y)) = b_0 + b_1 L_1 + \dots + b_n L_n</tex>, где <tex>L_j</tex> {{---}} булева функция от переменных <tex>x_i</tex> (например <tex>L_j = (x_2 \lor \overline{x_4}) \land x_7</tex>).
Для каждого типа модели необходимо определить функцию, которая отражает качество рассматриваемой модели. Например, для линейной регрессии такой функцией может быть остаточная сумма квадратов. Целью метода логической регрессии является минимизация выбранной функции качества посредством настройки параметров <tex>b_j</tex> одновременно с булевыми выражениями <tex>L_j</tex>.

[[Файл: Logic_tree_moves.jpg|400px|thumb|Рис.3. Допустимые действия в процессе роста дерева. Элементы, появившиеся в результате применения операции, выделены черным фоном.]]

Может показаться не совсем понятным, как же применить регрессию к булевым выражениям. Рассмотрим в общих чертах алгоритм логической регрессии.
Логическая регрессия, как и другие методы регрессии, перебирает различные выражения в попытках минимизировать функцию потерь. Для <tex>k</tex> переменных можно составить <tex>2^{2^k}</tex> различных выражений. Нужно найти более эффективный метод для поиска наилучшего выражения, чем простой перебор всех вариантов.

Любое логическое выражение можно представить в виде дерева, где в узлах расположены операции, а листья представляют собой переменные. Будем называть такие деревья '''логическими деревьями''' (англ. ''logic trees''). Будем называть '''соседями''' (англ. ''neighbours'') логического дерева такие деревья, которые могут быть получены из него за один шаг. Допустимые шаги проиллюстрированы на рисунке 3.

Рассмотрим самый простой алгоритм поиска наилучшего дерева {{---}} '''жадный поиск''' (англ. ''greedy search'').
# В качестве стартового дерева выберем одну переменную, которая дает минимальное значение функции потерь среди всех остальных переменных.
# Перебираем соседей текущего дерева и выбираем такое, что оно уменьшает значение функции потерь по сравнению с текущим, а также дает наименьший результат среди остальных соседей.
# Если такого дерева не существует, алгоритм завершается. Если оно все же есть, выбираем его в качестве текущего и повторяем второй шаг.

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

==См. также==
* [[Общие понятия]]
* [[Линейная регрессия]]
* [[Логистическая регрессия]]
* [[Обзор библиотек для машинного обучения на Python]]
* [[Байесовская классификация]]
* [[Уменьшение размерности]]

==Источники информации==
* [http://datareview.info/article/10-tipov-regressii-kakoy-vyibrat/ 10 типов регрессии {{---}} какой выбрать?]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F_%28%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%29 machinelearning.ru {{---}} Линейная регрессия (пример)]
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%A0%D0%B8%D0%B4%D0%B6-%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F machinelearning.ru {{---}} Ридж-регрессия]
* [http://www.ccas.ru/voron/download/Regression.pdf Лекции по алгоритмам восстановления регрессии К. В. Воронцов]
* [https://towardsdatascience.com/ridge-and-lasso-regression-a-complete-guide-with-python-scikit-learn-e20e34bcbf0b Ridge and Lasso Regression: A Complete Guide with Python Scikit-Learn]
* [https://habr.com/ru/company/ods/blog/322076/ Habr {{---}} Базовые принципы машинного обучения на примере линейной регрессии]
* [http://kooperberg.fhcrc.org/logic/documents/documents.html Documents on Logic Regression]

[[Категория: Машинное обучение]]
[[Категория: Регрессия]]

Примеры кода на Java

2019-04-08T23:14:58Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)#Пример на языке Java}}
===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Метод опорных векторов (SVM)

2019-04-08T23:14:18Z

91.215.123.110:

'''Метод опорных векторов''' (англ. ''support vector machine'', ''SVM'') — один из наиболее популярных методов обучения, который применяется для решения задач классификации и регрессии. Основная идея метода заключается в построении гиперплоскости, разделяющей объекты выборки наиболее оптимальным способом. Алгоритм работает в предположении, что чем больше расстояние (зазор) между разделяющей гиперплоскостью и объектами разделяемых классов, тем меньше будет средняя ошибка классификатора.

== Метод опорных векторов в задаче классификации ==

Рассмотрим задачу бинарной классификации, в которой объектам из $X=\mathbb{R}^n$ соответствует один из двух классов $Y = \{-1, +1\}$.

Пусть задана обучающая выборка пар "объект-ответ": $T^\ell = (\vec{x}_i, y_i)_{i=1}^\ell$. Необходимо построить алгоритм классификации $a(\vec{x}) : X \to Y$.

=== Разделяющая гиперплоскость ===

[[Файл:svm_hyperplane.png|300px|thumb|right|Примеры разделяющих гиперплоскостей в $\mathbb{R}^2$]]

В пространстве $\mathbb{R}^n$ уравнение $\langle \vec{w}, \vec{x} \rangle - b = 0$ при заданных $\vec{w}$ и $b$ определяет гиперплоскость — множество векторов $\vec{x} = (x_1, \ldots, x_n)$, принадлежащих пространству меньшей размерности $\mathbb{R}^{n-1}$. Например, для $\mathbb{R}^1$ гиперплоскостью является точка, для $\mathbb{R}^2$ — прямая, для $\mathbb{R}^3$ — плоскость и т.д. Параметр $\vec{w}$ определяет вектор нормали к гиперплоскости, а через $\frac{b}{\lVert \vec{w} \rVert}$ выражается расстояние от гиперплоскости до начала координат.

Гиперплоскость делит $\mathbb{R}^n$ на два полупространства: $\langle \vec{w}, \vec{x} \rangle - b > 0$ и $\langle \vec{w}, \vec{x} \rangle - b < 0$.

Говорят, что гиперплоскость разделяет два класса $C_1$ и $C_2$, если объекты этих классов лежат по разные стороны от гиперплоскости, то есть выполнено либо

$\begin{cases}\langle \vec{w}, \vec{x} \rangle - b > 0, && \forall x \in C_1 \\ \langle \vec{w}, \vec{x} \rangle - b < 0, && \forall x \in C_2\end{cases}$

либо

$\begin{cases}\langle \vec{w}, \vec{x} \rangle - b < 0, && \forall x \in C_1 \\ \langle \vec{w}, \vec{x} \rangle - b > 0, && \forall x \in C_2\end{cases}$

=== Линейно разделимая выборка ===

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

$a(\vec{x}) = sign(\langle \vec{w}, \vec{x} \rangle - b) = sign\left(\sum\limits_{i=1}^\ell w_i x_i - b\right)$

где $\vec{x} = (x_1, \ldots, x_n)$ — вектор значений признаков объекта, а $\vec{w} = (w_1, \ldots, w_n) \in \mathbb{R}^n$ и $b \in \mathbb{R}$ — параметры гиперплоскости.

Но для двух линейно разделимых классов возможны различные варианты построения разделяющих гиперплоскостей. Метод опорных векторов выбирает ту гиперплоскость, которая максимизирует отступ между классами:
{{Определение
|definition=
'''Отступ''' (англ. ''margin'') — характеристика, оценивающая, насколько объект "погружён" в свой класс, насколько типичным представителем класса он является. Чем меньше значение отступа $M_i$, тем ближе объект $\vec{x}_i$ подходит к границе классов и тем выше становится вероятность ошибки. Отступ $M_i$ отрицателен тогда и только тогда, когда алгоритм $a(x)$ допускает ошибку на объекте $\vec{x}_i$. Для линейного классификатора отступ определяется уравнением: $M_i(\vec{w}, b) = y_i(\langle \vec{w}, \vec{x}_i \rangle - b)$
}}
Если выборка линейно разделима, то существует такая гиперплоскость, отступ от которой до каждого объекта положителен:

$\exists \vec{w}, b : \; M_i(\vec{w}, b) = y_i(\langle \vec{w}, \vec{x}_i \rangle - b) > 0, \; i = 1\ldots\ell$

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

[[Файл:SVM_margin.png|300px|thumb|right|Оптимальная разделяющая гиперплоскость в $\mathbb{R}^2$]]
Заметим, что при умножении $\vec{w}$ и $b$ на константу $c \neq 0$ уравнение $\langle c\vec{w}, \vec{x} \rangle - cb = 0$ определяет ту же самую гиперплоскость, что и $\langle \vec{w}, \vec{x} \rangle - b = 0$. Для удобства проведём нормировку: выберем константу $c$ таким образом, чтобы $\min M_i(\vec{w}, b) = 1$. При этом в каждом из двух классов найдётся хотя бы один "граничный" объект обучающей выборки, отступ которого равен этому минимуму: иначе можно было бы сместить гиперплоскость в сторону класса с большим отступом, тем самым увеличив минимальное расстояние от гиперплоскости до объектов обучающей выборки.

Обозначим любой "граничный" объект из класса $+1$ как $\vec{x}_+$, из класса $-1$ как $\vec{x}_-$. Их отступ равен единице, то есть

$\begin{cases}
M_+(\vec{w}, b) = (+1)(\langle \vec{w}, \vec{x}_+ \rangle - b) = 1 \\
M_-(\vec{w}, b) = (-1)(\langle \vec{w}, \vec{x}_- \rangle - b) = 1
\end{cases}$

Нормировка позволяет ограничить разделяющую полосу между классами: $\{x: -1 < \langle \vec{w}, \vec{x}_i \rangle - b < 1\}$. Внутри неё не может лежать ни один объект обучающей выборки. Ширину разделяющей полосы можно выразить как проекцию вектора $\vec{x}_+ - \vec{x}_-$ на нормаль к гиперплоскости $\vec{w}$. Чтобы разделяющая гиперплоскость находилась на наибольшем расстоянии от точек выборки, ширина полосы должна быть максимальной:

$\frac{\langle \vec{x}_+ - \vec{x}_-, \vec{w} \rangle}{\lVert w \rVert} = \frac{\langle \vec{x}_+, \vec{w} \rangle - \langle \vec{x}_-, \vec{w} \rangle - b + b}{\lVert w \rVert} = \frac{(+1)\left(\langle \vec{x}_+, \vec{w} \rangle - b\right) \, + \, (-1)\left(\langle \vec{x}_-, \vec{w} \rangle - b\right)}{\lVert w \rVert} = \\ = \frac{M_+(\vec{w}, b) \, + \, M_-(\vec{w}, b)}{\lVert w \rVert} = \frac{2}{\lVert w \rVert} \to \max \; \Rightarrow \; \lVert w \rVert \to \min$

Это приводит нас к постановке задачи оптимизации в терминах квадратичного программирования:

$\begin{cases}
\lVert \vec{w} \rVert^2 \to \min\limits_{w,b} \\
M_i(\vec{w}, b) \geq 1, \quad i = 1, \ldots, \ell
\end{cases}$

=== Линейно неразделимая выборка ===

На практике линейно разделимые выборки практически не встречаются: в данных возможны выбросы и нечёткие границы между классами. В таком случае поставленная выше задача не имеет решений, и необходимо ослабить ограничения, позволив некоторым объектам попадать на "территорию" другого класса. Для каждого объекта отнимем от отступа некоторую положительную величину $\xi_i$, но потребуем чтобы эти введённые поправки были минимальны. Это приведёт к следующей постановке задачи, называемой также ''SVM с мягким отступом'' (англ. ''soft-margin SVM''):

$\begin{cases}
\frac{1}{2} \lVert \vec{w} \rVert^2 \color{brown}{+ C \sum\limits_{i=1}^\ell \xi_i} \to \min\limits_{w, b, \color{brown}{\xi}} \\
M_i(\vec{w}, b) \geq 1 \color{brown}{- \xi_i}, \quad i = 1, \ldots, \ell \\
\color{brown}{\xi_i \geq 0, \quad i = 1, \ldots, \ell} \\
\end{cases}$

Мы не знаем, какой из функционалов $\frac{1}{2} \lVert \vec{w} \rVert^2$ и $\sum\limits_{i=1}^\ell \xi_i$ важнее, поэтому вводим коэффициент $C$, который будем оптимизировать с помощью кросс-валидации. В итоге мы получили задачу, у которой всегда есть единственное решение.

Заметим, что мы можем упростить постановку задачи:

$\begin{cases}
\xi_i \geq 0 \\
\xi_i \geq 1 - M_i(\vec{w}, b) \\
\sum\limits_{i=1}^\ell \xi_i \to \min
\end{cases}
\,\Rightarrow\,
\begin{cases}
\xi_i \geq \max(0, 1 - M_i(\vec{w}, b)) \\
\sum\limits_{i=1}^\ell \xi_i \to \min
\end{cases}
\,\Rightarrow\,
\xi_i = (1- M_i(\vec{w}, b))_+$

Получим эквивалентную задачу безусловной минимизации:

$\frac{1}{2} \lVert \vec{w} \rVert^2 + C \sum\limits_{i=1}^\ell \left(1 - M_i(\vec{w}, b)\right)_+ \to \min\limits_{w, b}$

Теперь научимся её решать.

{{Теорема
|id=kkt
|author=Условия Каруша—Куна—Таккера
|statement=
Пусть поставлена задача нелинейного программирования с ограничениями:
$$
\begin{cases}
f(x) \to \min\limits_{x \in X} \\
g_i(x) \leq 0,\;i=1\ldots m \\
h_j(x) = 0,\;j=1\ldots k
\end{cases}
$$

Если $x$ — точка локального минимума при наложенных ограничениях, то существуют такие множители $\mu_i, i = 1\ldots m$, $\;\lambda_j, j = 1\ldots k$, что для функции Лагранжа $L(x; \mu, \lambda)$ выполняются условия:

$$\begin{cases}\frac{\partial L}{\partial x} = 0, \quad L(x; \mu, \lambda) = f(x) + \sum\limits_{i=1}^m \mu_i g_i(x) + \sum\limits_{j=1}^k \lambda_j h_j(x) \\ g_i(x) \leq 0,\;h_j(x) = 0 \quad \text{(исходные ограничения)} \\ \mu_i \geq 0 \quad \text{(двойственные ограничения)} \\ \mu_i g_i(x) = 0 \quad \text{(условие дополняющей нежёсткости)} \end{cases}$$

При этом искомая точка является седловой точкой функции Лагранжа: минимумом по $x$ и максимумом по двойственным переменным $\mu$.
}}

По теореме Каруша—Куна—Таккера, поставленная нами задача минимизации эквивалентна двойственной задаче поиска седловой точки функции Лагранжа:

$\mathscr{L}(\vec{w},b,\xi; \lambda, \eta) = \frac{1}{2} \lVert w \rVert^2 - \sum\limits_{i=1}^\ell \lambda_i \left(M_i(\vec{w}, b) - 1\right) - \sum\limits_{i=1}^\ell \xi_i \left(\lambda_i + \eta_i - C\right)$

$\lambda_i$ — переменные, двойственные к ограничениям $M_i \geq 1 - \xi_i$

$\eta_i$ — переменные, двойственные к ограничениям $\xi_i \geq 0$

Запишем необходимые условия седловой точки функции Лагранжа:

$\begin{cases}
\frac{\partial \mathscr{L}}{\partial w} = 0, \quad \frac{\partial \mathscr{L}}{\partial b} = 0, \quad \frac{\partial \mathscr{L}}{\partial \xi} = 0 \\
\xi_i \geq 0, \quad \lambda_i \geq 0, \quad \eta_i \geq 0, && i = 1, \ldots, \ell \\
\lambda_i = 0 \;\text{либо}\; M_i(\vec{w},b) = 1 - \xi_i, && i = 1, \ldots, \ell \\
\eta_i = 0 \;\text{либо}\; \xi_i = 0, && i = 1, \ldots, \ell
\end{cases}$

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

$\begin{array}{lcl}
\frac{\partial \mathscr{L}}{\partial w} = \vec{w} - \sum\limits_{i=1}^\ell \lambda_i y_i \vec{x}_i = 0 & \Rightarrow & \vec{w} = \sum\limits_{i=1}^\ell \lambda_i y_i \vec{x}_i \\
\frac{\partial \mathscr{L}}{\partial b} = -\sum\limits_{i=1}^\ell \lambda_i y_i = 0 & \Rightarrow & \sum\limits_{i=1}^\ell \lambda_i y_i = 0 \\
\frac{\partial \mathscr{L}}{\partial \xi_i} = -\lambda_i - \eta_i + C = 0 & \Rightarrow & \eta_i + \lambda_i = C, \quad i = 1, \ldots, \ell
\end{array}$

Заметим, что $\eta_i \geq 0$, $\lambda_i \geq 0$, $C > 0$, поэтому из последнего ограничения получаем $0 \leq \eta_i \leq C$, $0 \leq \lambda_i \leq C$.

Диапазон значений $\lambda_i$ (которые, как указано выше, соответствуют ограничениям на величину отступа) позволяет нам разделить объекты обучающей выборки на три типа:

# $\lambda_i = 0 \; \Rightarrow \; \eta_i = C; \; \xi_i = 0; \; M_i \geq 1 \;$ — периферийные (неинформативные) объекты Эти объекты лежат в своём классе, классифицируются верно и не влияют на выбор разделяющей гиперплоскости (см. уравнение для $\vec{w}$)
# $0 < \lambda_i < C \; \Rightarrow \; 0 < \eta_i < C; \; \xi_i = 0; \; M_i = 1 \;$ — опорные граничные объекты Эти объекты лежат ровно на границе разделяющей полосы на стороне своего класса
# $\lambda_i = C \; \Rightarrow \; \eta_i = 0; \; \xi_i > 0; \; M_i < 1 \;$ — опорные объекты-нарушители Эти объекты лежат внутри разделяющей полосы или на стороне чужого класса

{{Определение
|definition=
'''Опорный объект''' (опорный вектор, англ. ''support vector'') — объект $\vec{x}_i$, соответствующий которому множитель Лагранжа отличен от нуля: $\lambda_i \neq 0$.
}}

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

$\begin{cases}
-\mathscr{L}(\lambda) = -\sum\limits_{i=1}^\ell \lambda_i + \frac{1}{2} \sum\limits_{i=1}^\ell \sum\limits_{j=1}^\ell \lambda_i \lambda_j y_i y_j \langle \vec{x}_i, \vec{x}_j \rangle \to \min\limits_\lambda \\
0 \leq \lambda_i \leq C, \quad i = 1, \ldots, \ell \\
\sum\limits_{i=1}^\ell \lambda_i y_i = 0
\end{cases}$

Это также задача квадратичного программирования. Решение задачи лежит в пересечении $\ell$-мерного куба с ребром $C$ и гиперплоскости $\langle \lambda, y \rangle = 0$, что является выпуклым многогранником размерности $\ell-1$. В этом многограннике нужно найти минимум выпуклого квадратичного функционала. Следовательно, данная задача имеет единственное решение.

Существуют различные методы поиска решения: можно воспользоваться универсальным солвером задачи квадратичного программирования ([https://www.ibm.com/analytics/cplex-optimizer CPLEX], [http://www.gurobi.com/ Gurobi]), либо алгоритмом, учитывающим специфические особенности SVM ([https://www.microsoft.com/en-us/research/publication/sequential-minimal-optimization-a-fast-algorithm-for-training-support-vector-machines/ SMO], [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.9956 INCAS]).

После того, как мы получили вектор коэффициентов $\vec{\lambda}$, можем выразить решение прямой задачи через решение двойственной:

$\begin{cases}
\vec{w} = \sum\limits_{i=1}^\ell \lambda_i y_i \vec{x}_i \\
b = \langle \vec{w}, \vec{x}_i \rangle - y_i, \quad \forall i: \lambda_i > 0, M_i = 1
\end{cases}$

На практике для повышения вычислительной устойчивости рекомендуется при расчёте $b$ брать медиану по опорным граничным объектам:

$b = med\{ \langle \vec{w}, \vec{x}_i \rangle - y_i : \lambda_i > 0, M_i = 1, i = 1, \ldots, \ell\}$

Теперь можем переписать наш линейный классификатор, выразив $\vec{w}$ через $\vec{\lambda}$:

$a(x) = sign \left(\sum\limits_{i=1}^\ell \lambda_i y_i \langle \vec{x}_i, \vec{x} \rangle - b\right)$

=== Нелинейное обобщение, kernel trick ===

Существует ещё один подход к решению проблемы линейной разделимости, известный как трюк с ядром (kernel trick). Если выборка объектов с признаковым описанием из $X = \mathbb{R}^n$ не является линейно разделимой, мы можем предположить, что существует некоторое пространство $H$, вероятно, большей размерности, при переходе в которое выборка станет линейно разделимой. Пространство $H$ здесь называют спрямляющим, а функцию перехода $\psi : X \to H$ — спрямляющим отображением. Построение SVM в таком случае происходит так же, как и раньше, но в качестве векторов признаковых описаний используются векторы $\psi(\vec{x})$, а не $\vec{x}$. Соответственно, скалярное произведение $\langle \vec{x}_1, \vec{x}_2 \rangle$ в пространстве $X$ везде заменяется скалярным произведением $\langle \psi(\vec{x}_1), \psi(\vec{x}_2) \rangle$ в пространстве $H$. Отсюда следует, что пространство $H$ должно быть гильбертовым, так как в нём должно быть определено скалярное произведение.

Обратим внимание на то, что постановка задачи и алгоритм классификации не используют в явном виде признаковое описание и оперируют только скалярными произведениями признаков объектов. Это даёт возможность заменить скалярное произведение в пространстве $X$ на [[Ядра|ядро]] — функцию, являющуюся скалярным произведением в некотором $H$. При этом можно вообще не строить спрямляющее пространство в явном виде, и вместо подбора $\psi$ подбирать непосредственно ядро.

Постановка задачи с применением ядер приобретает вид:

$\begin{cases}
-\mathscr{L}(\lambda) = -\sum\limits_{i=1}^\ell \lambda_i + \frac{1}{2} \sum\limits_{i=1}^\ell \sum\limits_{j=1}^\ell \lambda_i \lambda_j y_i y_j \color{brown}{K(\vec{x}_i, \vec{x}_j)} \to \min\limits_\lambda \\
0 \leq \lambda_i \leq C, \quad i = 1, \ldots, \ell \\
\sum\limits_{i=1}^\ell \lambda_i y_i = 0
\end{cases}$

$a(x) = sign \left(\sum\limits_{i=1}^\ell \lambda_i y_i \color{brown}{K(\vec{x}_i, \vec{x})} - b\right)$

== Преимущества и недостатки SVM ==

Преимущества SVM перед методом стохастического градиента и нейронными сетями:

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

Недостатки классического SVM:

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

== Модификации ==

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

* [http://jmlr.csail.mit.edu/papers/v1/tipping01a.html Метод релевантных векторов (Relevance Vector Machine, RVM)]
* [https://papers.nips.cc/paper/2450-1-norm-support-vector-machines.pdf 1-norm SVM (LASSO SVM)]
* [http://www3.stat.sinica.edu.tw/statistica/oldpdf/A16n214.pdf Doubly Regularized SVM (ElasticNet SVM)]
* [https://arxiv.org/abs/1901.09643v1 Support Features Machine (SFM)]
* [http://www.robots.ox.ac.uk/~minhhoai/papers/SVMFeatureWeight_PR.pdf Relevance Features Machine (RFM)]

==Примеры кода==
===Пример на языке Java===
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

== См. также ==
* [[Общие понятия]]
* [[Ядра]]
* [[Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>

== Источники информации ==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%B0_%D0%BE%D0%BF%D0%BE%D1%80%D0%BD%D1%8B%D1%85_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2 machinelearning.ru — Машина опорных векторов]
* [https://www.youtube.com/watch?v=Adi67_94_gc&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=5 Лекция "Линейные методы классификации: метод опорных векторов"] — К.В. Воронцов, курс "Машинное обучение" 2014
* [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BE%D0%BF%D0%BE%D1%80%D0%BD%D1%8B%D1%85_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2 Wikipedia — Метод опорных векторов]
* Alexey Nefedov — [https://svmtutorial.online/ Support Vector Machines: A Simple Tutorial]
* John Platt — [https://www.microsoft.com/en-us/research/publication/sequential-minimal-optimization-a-fast-algorithm-for-training-support-vector-machines/ Sequential Minimal Optimization: A Fast Algorithm for Training Support Vector Machines]
* Shai Fine, Katya Scheinberg — [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.9956 INCAS: An Incremental Active Set Method for SVM]

[[Категория: Машинное обучение]]
[[Категория: Классификация]]
[[Категория: Регрессия]]

Примеры кода на Java

2019-04-08T23:10:26Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)}}
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Дерево решений и случайный лес

2019-04-08T14:23:35Z

91.215.123.110:

Дерево решений {{---}} логический алгоритм классификации, решающий задачи классификации и регрессии. Представляет собой объединение логических условий в структуру дерева.

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

{{Определение
|id=def1.
|neat =
|definition=
'''Дерево решений''' (англ. ''decision tree, DT'') {{---}} алгоритм классификации <tex>a(x) = (V_{внутр}, v_0, V_{лист}, S_v, \beta_v)</tex>, задающийся деревом (связным ациклическим графом), где:
* <tex> V = V_{внутр} \cup V_{лист} </tex> {{---}} множество вершин , <tex>v_0 \in V</tex> {{---}} корень дерева;
* <tex> S_v : D_v \rightarrow V_v </tex> {{---}} функция перехода по значению предиката в множество детей вершины <tex>v</tex>;
* <tex> \beta_v : X \rightarrow D_v </tex> {{---}} предикат ветвления, <tex>v \in V_{внутр}</tex> и <tex>|D_v| < \infty</tex>;
* Для листьев <tex>v \in V_{лист}</tex> определена метка класса <tex>y_v \in Y</tex>.
}}
{{Определение
|id=def1
|neat =
|definition=
'''Бинарное дерево решений''' {{---}} частный случай дерева решений, для которого <tex> D_v = \{0,1\} </tex>.
}}
[[Файл:BinDT.jpg |300px|thumb|right|Классификация объекта <tex> x \in X </tex> бинарным решающим деревом]]

'''function''' classify(x):
<tex>v = v_0</tex>
'''if''' <tex>\beta_v(x) = 1 </tex>
<tex>v := R_v</tex>
'''else'''
<tex>v := L_v</tex>
'''return''' <tex>y_v</tex>

===Информативность ветвления===
Для того, чтобы оценивать качество разбиения объектов по предикату <tex>\beta</tex>, введем понятие ''информационного выигрыша'' разбиения. 
Сначала оценим распределение значений классов объектов внутри каждого множества из разбиения, введя понятие ''меры неопределенности распределения''.
{{Определение
|id=def1
|neat =
|definition=
'''Частотная оценка вероятности класса <tex>y</tex> в вершине <tex>v \in V_{внутр}</tex> ''': 
<tex>p_y = P(y | x \in U) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}[y_i = y]</tex>
}}

{{Определение
|id=def1
|neat =
|definition=
'''Мера неопределенности (англ. ''impurity'') распределения <tex>p_y</tex>''': 
* минимальна, когда <tex>p_y \in \{0,1\}</tex>;
* максимальна, когда <tex>p_y = \frac{1}{|Y|}</tex> для всех <tex>y \in Y</tex>;
* не зависит от перенумерации классов
<tex>Ф(U) = \sum\nolimits_{y \in Y} p_y L(p_y) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}L(P(y_i | x_i \in U)) \rightarrow min</tex>, где <tex>L(p)</tex> убывает и <tex>L(1) = 0</tex>, например: <tex>-log_2(p)</tex>, <tex>1 - p</tex>, <tex>1 - p^2</tex>
}}

Примерами мер неопределенности распределения являются:
* Энтропия: <tex>Ф(U) = -\sum\limits_{i}^N p_i log_2p_i</tex>, определяется для каждого множества из разбиения, <tex>N</tex> {{---}} количество возможных классов, и <tex>p_i</tex> {{---}} вероятность объекта принадлежать <tex> i</tex>-ому классу.
* Критерий Джини: <tex>Ф(U) = \sum\nolimits_{i != j}p_i p_j = \sum\nolimits_{i}p_i*(1-p_i)</tex>, максимизацию этого критерия можно интерпретировать как максимизацию числа пар объектов одного класса, оказавшихся после разбиения в одном множестве. 

Теперь определим суммарную ''неопределенность распределения'' в разбиении.
{{Определение
|id=def1
|neat =
|definition=
'''Неопределенность распределения <tex>P(y_i | x_i \in U_{\beta(x_i)})</tex> после ветвления вершины <tex>v</tex> по предикату <tex>\beta</tex> и разбиения <tex>U = \bigcup_{k \in D_v} U_k</tex>''': 
<tex>Ф(U_0, ... ,U_{D_v}) = \frac{1}{|U|} \sum\nolimits_{k \in D_v} \sum\nolimits_{x_i \in U_k}L(P(y_i | x_i \in U_k)) = \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k)</tex>
}}

''Информационный выигрыш'' от разбиения определяется как изменение неопределенности в системе.
{{Определение
|id=def1
|neat =
|definition=
'''Информационный выигрыш от разбиения по предикату <tex>\beta</tex>''' 
<tex>Gain(\beta, U) = Ф(U) - Ф(U_1, ... ,U_{|D_v|}) = Ф(U) - \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k) \rightarrow max_{\beta \in B} </tex>
}}

=== Рекурсивный алгоритм построения бинарного дерева решений ID3 ===
Покажем идею построения дерева решения на частном случае бинарного дерева. Алгоритм <tex>ID3</tex> (англ. ''Induction of Decision Tree'') заключается в последовательном дроблении выборки на две части до тех пор, пока в каждой части не окажутся объекты только одного класса. Разделение производится по предикату <tex>\beta</tex>, который выбирается из множества элементарных предикатов. На практике в качестве элементарных предикатов чаще всего берут простые пороговые условия вида <tex>\beta(x) = [f_j(x) >= d_j]</tex>.
 Проще всего записать этот алгоритм в виде рекурсивной процедуры <tex>ID3</tex>, которая строит дерево по заданной подвыборке <tex>U</tex> и возвращает его корневую вершину.

1:'''function''' ID3(<tex>U</tex>):
2: '''if''' <tex>for all</tex> <tex>u \in U</tex>: <tex>y_u = y</tex>, <tex>y \in Y</tex>
// создать листовую вершину <tex>v</tex> c меткой класса <tex>y_v</tex> 
3: v = createLeafVertex(<tex>y_v</tex>)
4: '''return''' v
// найти предикат с максимальным информационным выигрышом 
<tex>\beta= \mathrm{arg}\max_{\beta\in B} </tex> Gain(<tex>\beta</tex>, <tex>U</tex>)
// разбить выборку на две части <tex>U = U_0 \cup U_1</tex> по предикату <tex>\beta</tex> 
5: <tex>U_0 := \{x \in U: \beta(x) = 0\}</tex>
6: <tex>U_1 := \{x \in U: \beta(x) = 1\}</tex>
7: '''if''' <tex>U_0 = \emptyset</tex> || <tex>U_1 = \emptyset</tex>
// найти класс, в котором находится большинство объектов из <tex>U</tex> 
8: <tex>y_v</tex> = majorClass(<tex>U</tex>)
9: v = createLeafVertex(<tex>y_v</tex>)
'''else'''
// создать внутреннюю вершину <tex>v</tex>
10: v = createVertex()
11: <tex>\beta_v = \beta</tex>
12: <tex>S_0</tex> = ID3(<tex>U_0</tex>)
13: <tex>S_1</tex> = ID3(<tex>U_1</tex>)
14: '''return''' <tex>v</tex>

== Редукция решающих деревьев ==
Суть редукции (англ. ''pruning'') состоит в удалении поддеревьев, имеющих недостаточную статистическую надёжность. При этом дерево перестаёт безошибочно классифицировать обучающую выборку, зато качество классификации новых объектов, как правило, улучшается. Рассмотрим наиболее простые варианты редукции.

===Предредукция===
Предредукция (англ. ''pre-pruning'') или критерий раннего останова досрочно прекращает дальнейшее ветвление в вершине дерева, если информативность <tex>I(\beta, U)</tex> для всех возможных предикатов <tex>\beta</tex> не дотягивает до заданного порогового значения <tex>I_0</tex>. 
Для этого на шаге 8 алгоритма <tex>ID3</tex> условие <tex>U_0 = \emptyset</tex> или <tex>U_1 = \emptyset</tex> заменяется условием <tex>I(\beta, U) <= I_0 </tex>. Порог <tex>I_0 </tex> является управляющим параметром метода. 
Предредукция считается не самым эффективным способом избежать переобучения, так как жадное ветвление по-прежнему остаётся глобально неоптимальным. Более эффективной считается cтратегия постредукции.

===Постредукция===
Постредукция (англ. ''post-pruning'') просматривает все внутренние вершины дерева и заменяет отдельные вершины либо одной из дочерних вершин (при этом вторая дочерняя удаляется), либо терминальной вершиной. Процесс замен продолжается до тех
пор, пока в дереве остаются вершины, удовлетворяющие критерию замены. 
''Критерием замены'' является сокращение числа ошибок на контрольной выборке, отобранной заранее, и не участвовавшей в обучении дерева. Стандартная рекомендация — оставлять в контроле около 30% объектов. 
Для реализации постредукции контрольная выборка <tex>X^k</tex> пропускается через
построенное дерево. При этом в каждой внутренней вершине <tex>v</tex> запоминается подмножество <tex>S_v \subseteq X_k</tex> попавших в неё контрольных объектов. Если <tex>S_v = \emptyset </tex>, то вершина <tex>v</tex> считается ненадёжной и заменяется терминальной по ''мажоритарному правилу'': 
в качестве <tex>y_v</tex> берётся тот класс, объектов которого больше всего в обучающей подвыборке <tex>U</tex>, пришедшей в вершину <tex>v</tex>. 
Затем для каждой внутренней вершины <tex>v</tex> вычисляется число ошибок, полученных при классификации выборки <tex>S_v</tex> следующими способами: 
* <tex>r(v)</tex> — классификация поддеревом, растущим из вершины <tex>v</tex>;
* <tex>r_L(v)</tex> — классификация поддеревом левой дочерней вершины <tex>L_v</tex>;
* <tex>r_R(v)</tex> — классификация поддеревом правой дочерней вершины <tex>R_v</tex>;
* <tex>r_c(v)</tex> — отнесение всех объектов выборки <tex>S_v</tex> к классу <tex>y \in Y</tex>. 
Эти величины сравниваются, и в зависимости от того, какая из них оказалась
минимальной, принимается, соответственно, одно из четырёх решений: 
* сохранить поддерево вершины <tex>v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом левой дочерней вершины <tex>L_v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом правой дочерней вершины <tex>R_v</tex>;
* заменить поддерево <tex>v</tex> терминальной вершиной класса <tex>y_v = \mathrm{arg}\min_{y\in Y}r_c(v) </tex>.

== Алгоритмы построения деревьев решения ==
Недостатки рассмотренного алгоритма ID3:
* Применим только для дискретных значений признаков;
* Переобучение;
* На каждом шаге решение принимается по одному атрибуту.

=== Алгоритм [https://en.wikipedia.org/wiki/Predictive_analytics#Classification_and_regression_trees_.28CART.29 CART] (англ. ''Classification And Regression Trees'')===
* В отличие от ID3 работает и с непрерывными значениями признаков: на каждом шаге построения дерева последовательно сравнивает все возможные разбиения для всех атрибутов и выбирает наилучший атрибут и наилучшее разбиение для него. Разбивает объекты на две части;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

=== Алгоритм [https://en.wikipedia.org/wiki/C4.5_algorithm C4.5] ===
* Также работает и с непрерывными значениями признаков: на каждом шаге построения дерева выбирает правило разбиения по одному из признаков. Разбивает объекты на несколько частей по этому правилу, рекурсивно запускается из полученных подмножеств;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

== Случайный лес ==
Случайный лес {{---}} один из примеров объединения классификаторов в [[Виды_ансамблей|ансамбль]]. 
Алгоритм построения случайного леса, состоящего из <tex>N</tex> деревьев на основе обучающей выборки <tex>X</tex> такой:
'''for''' (n: 1,...,N):
// сгенерировать выборку <tex>X_n</tex> c помощью [[Виды_ансамблей#Бутстрэп|бутстрэпа]]
<tex>X_n</tex> = bootstrap(<tex>X</tex>)
// построить решающее дерево <tex>t_n</tex> по выборке <tex>X_n</tex>
<tex>t_n</tex> = ID3(<tex>X_n</tex>) 

Итоговый классификатор {{---}} <tex>a(x) = \frac{1}{N} \sum\limits_{i = 1}^{N} t_i(x)</tex>. Для задачи классификации мы выбираем решение по большинству результатов, выданных классификаторами, а в задаче регрессии {{---}} по их среднему значению. 

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

==Примеры кода==
===Примеры на языке Python===
*Для решения задач классификации и регрессии используют [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier DecisionTreeClassifier], [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html#sklearn.tree.DecisionTreeRegressor DecisionTreeRegressor];

*В '''sklearn.ensemble''' также представлены методы классификации, основанные на ансамблях, в том числе: [https://scikit-learn.org/stable/modules/ensemble.html#bagging бэггинг] и [https://scikit-learn.org/stable/modules/ensemble.html#forest случайный лес], которые были описаны выше.
 Так, в этом примере создается бэггинг ансамбль из классификаторов '''KNeighborsClassifier''', каждый из которых обучен на случайных подмножествах из 50% объектов из обучающей выборки, и 50% случайно выбранных признаков.

'''from''' sklearn.ensemble '''import''' BaggingClassifier
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier
bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)

Пример использования классификатора на случайном лесе:
Полную версию кода можно найти [https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-download-auto-examples-classification-plot-classifier-comparison-py| здесь]
'''from''' sklearn '''import''' RandomForestClassifier
'''from''' sklearn.datasets '''import''' make_classification
// сгенерируем случайную обучающую выборку с классификацией по n_classes классам
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=2)
// разбиваем выборку на обучающую и тестовую 
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
// создадим классификатор на случайном лесе, состоящим из n_estimators деревьев
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)

Результат классификации показан на рисунке.

[[Файл:RFC.png |800px|thumb|center|Классификация RandomForestClassifier. Кружочками изображены объекты обучающей выборки, крестиками тестовой выборки. Справа цветом выделены границы принятия решений, в правом нижнем углу {{---}} значение accuracy.]]

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.cart<ref>[https://haifengl.github.io/smile/classification.html#cart Smile, Decision Trees]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''dt: DecisionTree = cart(x, y, 1000)
'''val '''predictions: Array['''Int'''] = x.map(dt.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, dt)

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.trees.RandomForest</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/trees/RandomForest.html Weka, Random Forest]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.classifiers.trees.RandomForest;

// read dataset
'''var''' trainingDataSet = getDataSet(...);
'''var''' testingDataSet = getDataSet(...);
// create random forest classifier
'''var''' forest = new RandomForest();
forest.setMaxDepth(15);
forest.setNumFeatures(2);
forest.buildClassifier(trainingDataSet);
// evaluate the model on test dataset and print summary
'''var''' eval = new Evaluation(trainingDataSet);
eval.evaluateModel(forest, testingDataSet);
System.out.println(eval.toSummaryString());

== См. также ==
* [[Виды ансамблей]]

== Источники информации ==
# [http://www.machinelearning.ru/wiki/images/3/3e/Voron-ML-Logic.pdf Логические алгоритмы классификации] {{---}} Лекция К. В. Воронцова
# [https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-5-ensembles-of-algorithms-and-random-forest-8e05246cbba7 Случайный лес] {{---}} статья на Medium, Yury Kashnitskiy
# [https://scikit-learn.org/stable/modules/tree.html Деревья решений] {{---}} scikit-learn.org
#[https://scikit-learn.org/stable/modules/ensemble.html Ансамбли классификаторов] — scikit-learn.org.

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Бустинг, AdaBoost

2019-04-08T14:23:04Z

91.215.123.110:

==Описание==
'''Бустинг''' (англ. ''boosting'') {{---}} [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ.

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

==Алгоритмы бустинга==
{{Определение
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок, <center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center> , Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>,

Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.

Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.

Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.

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

Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]][на 28.01.19 не создан], [[Метод опорных векторов (SVM)|методы опорных векторов]][на 28.01.19 не создан], смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.

===Задача ранжирования выдачи поисковых систем===
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.

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

AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.

===Описание алгоритма===

//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex>
'''function''' AdaBoost($X$, $Y$, $m$):
//Инициализируем
'''for''' i = 1..m '''do''':
<tex>D_i^1 = \frac{1}{m}</tex>
'''end''' '''for'''

'''for''' t = 1..T '''do''':
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> //$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex>
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex>
'''for''' i = 1..m '''do''':
//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex>
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex>
'''end''' '''for'''
'''end''' '''for'''
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> //$H(x)$ {{---}} результирующий классификатор
'''return''' $H$
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>,

Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.

===Пример работы===
Рассмотрим набор данных, которые пометим как $-$ и $+$.
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]
Рассмотрим результат после $2$-х итераций:
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.

===Достоинства и недостатки===
'''Достоинства:'''
# Простота реализации;
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов;
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов;
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.
'''Недостатки:'''
# Склонен к переобучению при наличии значительного уровня шума в данных;
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.

===Пример кода на python для scikit-learn===
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.
Наиболее важными являются:
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1);
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше;
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).

'''from''' sklearn.ensemble '''import''' AdaBoostClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split
'''from''' sklearn '''import''' metrics

iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.8888888888888888

Теперь рассмотрим алгоритм с SVC в качестве базы:
'''from''' sklearn.svm '''import''' SVC

svc=SVC(probability='''True''', kernel=''''linear'''')

abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.9555555555555556

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, ada)

===Пример на языке Java===
Пример классификации с применением <code>smile.classification.AdaBoost</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/AdaBoost.html/ Smile, AdaBoost]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.AdaBoost;
'''import''' smile.data.parser.ArffParser;
'''import''' smile.validation.Accuracy;
'''import''' smile.validation.ClassificationMeasure;
'''import''' smile.validation.FMeasure;
'''import''' java.util.Arrays;

// load train and test datasets
'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(0);
'''var''' train = arffParser.parse(this.getClass().getResourceAsStream("train.arff"));
'''var''' test = arffParser.parse(this.getClass().getResouceAsStream("test.arff"));
// create adaboost classifier
'''var''' forest = new AdaBoost(train.attributes(), train.x(), train.labels(), 200, 4);
// measure accuracy and F1-measure on test dataset
'''var''' measures = new ClassificationMeasure[]{new FMeasure(), new Accuracy()};
'''var''' results = forest.test(test.x(), test.labels(), measures);
System.out.println(Arrays.deepToString(results));

== См. также ==
*[[Метод опорных векторов (SVM)|Метод опорных векторов]][на 28.01.19 не создан]
*[[Байесовская классификация|Байесовская классификация]][на 28.01.19 не создан]
*[[Мета-обучение|Мета-обучение]]
*[[Нейронные сети, перцептрон|Нейронные сети]]
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]
*[[CatBoost|CatBoost]]

== Примечания==
<references />

== Источники информации ==
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.
[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]
[[Категория: Ансамбли]]

Уменьшение размерности

2019-04-08T14:22:24Z

91.215.123.110:

Под '''уменьшением размерности''' (англ. ''dimensionality reduction'') в машинном обучении подразумевается уменьшение числа признаков набора данных. Наличие в нем признаков избыточных, неинформативных или слабо информативных может понизить эффективность модели, а после такого преобразования она упрощается, и соответственно уменьшается размер набора данных в памяти и ускоряется работа алгоритмов ML на нем. Уменьшение размерности может быть осуществлено методами выбора признаков (англ. ''feature selection'') или выделения признаков (англ. ''feature extraction'').
==Выбор признаков==
Методы '''выбора признаков''' оставляют некоторое подмножество исходного набора признаков, избавляясь от признаков избыточных и слабо информативных. Основные преимущества этого класса алгоритмов:
*Уменьшение вероятности [[переобучение|переобучения]];
*Увеличение точности предсказания модели;
*Сокращение времени обучения;
*Увеличивается семантическое понимание модели.

Все методы выбора признаков можно разделить на 5 типов, которые отличаются алгоритмами выбора лишних признаков.
===Фильтры===
'''Фильтры''' (англ. ''filter methods'') измеряют релевантность признаков на основе функции $\mu$, и затем решают по правилу $\kappa$, какие признаки оставить в результирующем множестве.

Фильтры могут быть:
*Одномерные (англ. ''univariate'') {{---}} функция $\mu$ определяет релевантность одного признака по отношению к выходным меткам. В таком случае обычно измеряют "качество" каждого признака и удаляют худшие;
*Многомерные (англ. ''multivariate'') {{---}} функция $\mu$ определяет релевантность некоторого подмножества исходного множества признаков относительно выходных меток.

Распространенными вариантами для $\mu$ являются:
*Коэффициент ранговой корреляции Спирмена <ref>[https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient Определение коэффициента ранговой корреляции Спирмена]</ref>(англ. ''Spearman's rank correlation coefficient''): $p(x, y)=\displaystyle \frac{\sum_{i, j}(x_{ij}-\bar{x_j})(y_i-\bar{y})}{\sqrt{\sum_{i, j}(x_{ij}-\bar{x_j})^2\sum_i(y_i-\bar{y})^2}}$;
*Information gain<ref>[https://en.wikipedia.org/wiki/Information_gain_in_decision_trees Определение information gain]</ref>: $IG(x, y)=\displaystyle -\sum_{i=1}^kp(c_i)\log_2{(p(c_i))}+\sum_{i=1}^{n}p(t_i)\sum_{j=1}^kp(c_j|t_i)log_2{(p(c_j|t_i))}$, и другие.

Преимуществом группы фильтров является простота вычисления релевантности признаков в наборе данных, но недостатком в таком подходе является игнорирование возможных зависимостей между признаками.
===Оберточные методы===
[[File:Feature_selection_wrapper_rus.png|450px|thumb|right|Процесс работы оберточных методов]]
'''Оберточные методы''' (англ. ''wrapper methods'') находят подмножество искомых признаков последовательно, используя некоторый классификатор как источник оценки качества выбранных признаков, т.е. этот процесс является циклическим и продолжается до тех пор, пока не будут достигнуты заданные условия останова. Оберточные методы учитывают зависимости между признаками, что является преимуществом по сравнению с фильтрами, к тому же показывают большую точность, но вычисления занимают длительное время, и повышается риск [[переобучение|переобучения]].

Существует несколько типов оберточных методов: детерминированные, которые изменяют множество признаков по определенному правилу, а также рандомизированные, которые используют генетические алгоритмы для выбора искомого подмножества признаков. Среди детерминированных алгоритмов самыми простыми являются:
*SFS (Sequential Forward Selection) {{---}} жадный алгоритм, который начинает с пустого множества признаков, на каждом шаге добавляя лучший из еще не выбранных признаков в результирующее множество;
*SBS (Sequential Backward Selection) {{---}} алгоритм обратный SFS, который начинает с изначального множества признаков, и удаляет по одному или несколько худших признаков на каждом шаге.

Популярным оберточным методом является SVM-RFE (SVM-based Recursive Feature Elimination), который иногда также обозначается как встроенный <ref>[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117/ C. Embedded method]</ref>. Этот метод использует как классификатор [[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан] и работает итеративно: начиная с полного множества признаков обучает классификатор, ранжирует признаки по весам, которые им присвоил классификатор, убирает какое-то число признаков и повторяет процесс с оставшегося подмножества фичей, если не было достигнуто их требуемое количество. Таким образом, этот метод очень похож на встроенный, потому что непосредственно использует знание того, как устроен классификатор.

===Встроенные методы===
[[File:Feature_selection_embedded_rus.png|450px|thumb|right|Процесс работы встроенных методов]]
Группа '''встроенных методов''' (англ. ''embedded methods'') очень похожа на оберточные методы, но для выбора признаков используется непосредственно структуру некоторого классификатора. В оберточных методах классификатор служит только для оценки работы на данном множестве признаков, тогда как встроенные методы используют какую-то информацию о признаках, которую классификаторы присваивают во время обучения.

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

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

===Другие методы===
[[File:Feature_selection_ensemble_rus.png|thumb|Один из примеров процесса работы ансамблевых методов]]
Есть и другие методы выбора признаков: '''гибридные''' (англ. ''hybrid methods'') и '''ансамблевые''' (англ. ''ensemble methods''). '''Гибридные методы''' комбинируют несколько разных методов выбора признаков, например, некоторое множество фильтров, а потом запускают оберточный или встроенный метод. Таким образом, гибридные методы сочетают в себе преимущества сразу нескольких методов, и на практике повышают эффективность выбора признаков.

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

<div style="clear:{{{1|both}}};"></div>

===Примеры кода scikit-learn===
Пример кода, реализующего функцию оценки фильтра на основе коэффициента ранговой корреляции:
# Импорт библиотек
import pandas as pd
import numpy as np

# Вспомогательная функция для расчета корреляции
def correlation(X, Y):
return np.cov(X, Y) / np.sqrt(np.var(X) * np.var(Y))

# Сам фильтр на основе метрики ранговой корреляции
# Аргументы X -- значения объектов датасета для какой-то фичи, Y -- метки этих объектов
def measure_spearmans(X, Y):
xr = pd.Series(X).rank()
yr = pd.Series(Y).rank()
return correlation(xr, yr)

Пример кода, реализующего SVM-RFE wrapper:
# Импорт библиотек
import numpy as np
import pandas as pd
from sklearn import svm

# X -- наш датасет, Y -- массив меток
# N -- число признаков, которые хотим оставить, step -- сколько фичей удаляется на каждой итерации
# Возвращает массив из булевых переменных размерностью 1x[число признаков], показывающий, отбрасываем признак или нет
def RFE(X, Y, N, step = 10):
# cache_size нужен, если набор данных большой, иначе можно опустить
clfRFE = svm.SVC(kernel='linear', cache_size=1024)
featureCount = X.shape[1]
featureList = np.arange(0, featureCount )
included = np.full(featureCount, True)
curCount = featureCount
while curCount > N:
actualFeatures = featureList[included]
Xnew = X[:, actualFeatures]

clfRFE.fit(Xnew, Y)
curStep = min(step, curCount - N)
elim = np.argsort(np.abs(clfRFE.coef_[0]))[:curStep]
included[actualFeatures[elim]] = False
curCount -= curStep
return included
==Выделение признаков==
Другим способом уменьшить размерность входных данных является выделение признаков. Эти методы каким-то образом составляют из уже исходных признаков новые, все также полностью описывающие пространство набора данных, но уменьшая его размерность и теряя в репрезентативности данных, т.к. становится непонятно, за что отвечают новые признаки.
Все методы feature extraction можно разделить на '''линейные''' и '''нелинейные'''.

Одним из самых известных методов '''линейного''' выделения признаков является [[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан] (Principal Component Analysis, рус. ''метод главных компонент''). Основной идеей этого метода является поиск такой гиперплоскости, на которую при ортогональной проекции всех признаков максимизируется дисперсия. Данное преобразование может быть произведено с помощью сингулярного разложения матриц и создает проекцию только на линейные многомерные плоскости, поэтому и метод находится в категории линейных.

К '''нелинейным''' методам, например, могут быть отнесены методы отображающие исходное пространство признаков на нелинейные поверхности или топологические многообразия. Одним из таких алгоритмов является [[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан] (t-distributed Stochastic Neighbor Embedding, рус. ''стохастическое вложение соседей с t-распределением''). Данный метод состоит из двух шагов: изначально строится распределение вероятностей по всем парам точек набора данных, каждая условная вероятность $p_{j|i}$ которого означает насколько точка $X_j$ близка к точке $X_i$ при гауссовом распределении вокруг $X_i$. Данное распределение как метрику похожести использует евклидово расстояние. Алгоритм старается получить отображение из точек размерности $\mathbb{R}^k$ в меньшую размерность $\mathbb{R}^d$, для этого вводится еще одно распределение, описывающее насколько точки из нового пространства похожи друг на друга, но используя при этом t-распределение Стьюдента с одной степенью свободы. Как метрику похожести двух распределений используется дивергенция Кульбака-Лейблера<ref>[https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence Дивергенция Кульбака-Лейблера]</ref>, и чтобы найти точки новой размерности $d$ запускается градиентный спуск для минимизации этой величины.
===Пример кода scikit-learn===
Пример выделения признаков с помощью PCA в scikit-learn:
# Импорт библиотек
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split

X = ... # загрузка X
Y = ... # загрузка Y
# Разделение данных на train и test
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y)

clf = ... # берем какой-то классификатор
# Обучаем PCA для выделения 5 признаков
pca = PCA(n_components=5)
pca.fit(Xtrain)
# Изменяем наши наборы данных под выбранные признаки
Xtrain = pca.transform(Xtrain)
Xtest = pca.transform(Xtest)
# Обучаем классификатор и проверяем точность его работы
clf.fit(Xtrain, Ytrain)
print ("Score: %.6f" % clf.score(Xtest, Ytest))

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример уменьшение размерности используя smile.feature.GAFeatureSelection<ref>[https://haifengl.github.io/smile/feature.html#genetic-algorithm-feature-selection Smile, Genetic Algorithm Based Feature Selection]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.feature.GAFeatureSelection
'''import '''smile.read
'''import '''smile.validation.Accuracy

// Загрузка данных
'''val '''data = read.arff("data/weka/segment-test.arff", 19)
'''val '''(x, y) = data.unzipInt
'''val '''trainer = '''new '''GradientTreeBoost.Trainer(100)
'''val '''measure = '''new '''Accuracy
// Cоздание генетического алгоритма и его настройка.
'''val '''selector = '''new '''GAFeatureSelection
// Размер популяции - 50, количество поколений - 20 
// Каждая возращаемая BitString содержит фичи и их качество.
'''val '''result = selector.learn(50, 20, trainer, measure, x, y, 5)
result.foreach { bits =>
print(100*bits.fitness)
println(bits.bits.mkString(" "))
}

===Пример на языке Java===
Пример уменьшения размерности датасета с применением <code>weka.attributeSelection.PrincipalComponents</code><ref>[http://weka.sourceforge.net/doc.dev/weka/attributeSelection/PrincipalComponents.html/ Weka, PCA]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.attributeSelection.PrincipalComponents;
'''import''' weka.core.Instances;
'''import''' weka.filters.Filter;
'''import''' weka.filters.unsupervised.attribute.NumericToNominal;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;

// load dataset
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
'''var''' filter = new NumericToNominal();
filter.setInputFormat(data);
data = Filter.useFilter(data, filter);
// initialize the PCA-based selector
'''var''' pca = new PrincipalComponents();
// dimensionality reduction is achieved through selecting enough eigenvectors to account
// for some percantege of the variance in the original data
pca.setVarianceCovered(0.95);
pca.buildEvaluator(data);
// transform the dataset
data = pca.transformedData(data);

==См. также==
*[[Переобучение]]
*[[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан]
*[[Дерево решений и случайный лес| Случайный лес]]
*[[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан]
*[[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан]
==Примечания==
<references/>
==Источники информации==
#[http://research.cs.tamu.edu/prism/lectures/pr/pr_l11.pdf Sequential feature selection] {{---}} курс ML Texas A&M University
#[https://en.wikipedia.org/wiki/Feature_selection Feature selection] {{---}} статья про Feature Selection в Wikipedia
#[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117 Публикация про feature selection]
#[https://towardsdatascience.com/feature-selection-using-random-forest-26d7b747597f Embedded random forest]

[[Категория: Машинное обучение]]
[[Категория: Уменьшение размерности]]

Байесовская классификация

2019-04-08T14:21:45Z

91.215.123.110:

== Вероятностная постановка задачи классификации ==

Пусть $X$ множество объектов, $Y$ конечное множество имён классов,
множество $X \times Y$ является вероятностным пространством с плотностью распределения $p(x,y)=P(y)p(x|y)$.
Вероятности появления объектов каждого из классов $P_y=P(y)$ называются ''априорными вероятностями классов''.
Плотности распределения $p_y(x)=p(x|y)$ называются ''функциями правдоподобия классов''.

'''Вероятностная постановка задачи классификации разделяется на две независимые подзадачи:'''
* Имеется простая выборка $X^l=(x_i, y_i)^l_{i=1}$ из неизвестного распределения $p(x,y)=P_yp_y(x)$. Требуется построить ''эмпирические оценки'' априорных вероятностей $P'_y$ и функций правдоподобия $p'_y(x)$ для каждого из классов $y \in Y$.
* По известным плотностям распределения $p_y(x)$ и априорным вероятностям $P_y$ всех классов $y \in Y$ построить алгоритм $a(x)$, минимизирующий вероятность ошибочной классификации.

Априорные вероятности классов $P_y$ можно оценить согласно закону больших чисел,
тогда частота появления объектов каждого из классов равна $P'_y=\frac{l_y}{l}$ где $l_y=|X^l_y|, y \in Y$
сходится по вероятности к $P_y$ при $l_y \to \infty$. Чем больше длина выборки, тем точнее выборочная оценка $P'_y$.

== Оптимальный байесовский классификатор ==

Рассмотрим произвольный алгоритм $a:X \to Y$.
Он разбивает множество $X$ на не пересекающиеся области $A_y=\{x \in X | a(x) = y\}, y \in Y$.
Вероятность того,что появится объект класса $y$ и алгоритм $a$ отнесёт его к классу $s$, равна $P_yP(A_s|y)$.
Каждой паре $(y,s) \in Y \times Y$ поставим в соответствие величину потери $\lambda_{ys}$
при отнесении объекта класса $y$ к классу $s$.

{{Определение
|definition =
'''Функционал среднего риска''' {{---}} ожидаемая величина потери при классификации объектов алгоритмом $a$:
:<tex> R(a) = \displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) </tex>
}}

{{Теорема
|about=
об оптимальности байесовского классификатора
|statement=
Если известны априорные вероятности $P_y$ и функции правдоподобия $p_y(x)$,
то минимум среднего риска $R(a)$ достигается алгоритмом
:<tex> a(x) = \displaystyle\arg\min_{s \in Y}\sum_{y \in Y}\lambda_{ys}P_yp_y(x) </tex>
|proof=

Для произвольного $t \in Y$ запишем функционал среднего риска:

:<tex> R(a)=\displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) = \sum_{y \in Y}\lambda_{yt}P_yP(A_t|y) + \sum_{s \in Y\setminus\{t\} }\sum_{y \in Y}\lambda_{ys}P_yP(A_s|y).</tex>

Применив формулу полной вероятности, $P(A_t \mid y) = 1 −\displaystyle\sum_{ s \in Y \setminus \{t\} }P(A_s \mid y)$, получим:

:<tex> R(a) = \displaystyle\sum_{y \in Y}\lambda_{yt}P_y + \sum_{ s \in Y \setminus \{t\} } \sum_{y \in Y} (\lambda_{ys} - \lambda_{yt})P_yP(A_s|y) = </tex>

:<tex> = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} } \int_{A_s}\sum_{y \in Y} (\lambda_{ys}−\lambda_{yt})P_yp_y(x)dx. </tex>

Введём для сокращения записи обозначение
$g_s(x) = \displaystyle\sum_{y \in Y}\lambda_{ys}P_yp_y(x)$, тогда
$R(a) = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} }\int_{A_s}(g_s(x)−g_t(x))dx$.

Минимум интегрла достигается, когда $A_s$ совпадает с областью неположительности подынтегрального выражения.
:<tex> A_s=\{x \in X \mid g_s(x) \leq g_t(x), \forall t \in Y, t \leq s\}. </tex>

С другой стороны, $A_s=\{x \in X \mid a(x) = s\}$. Значит, $a(x) = s$ тогда и только тогда, когда
:$s= \displaystyle\arg\min_{t \in Y}g_t(x)$.
}}

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

Допустим, что объекты $x \in X$ описываются $n$ числовыми признаками $f_j:X→R,j= 1,...,n$.
Обозначим через $x = (\xi_1,...,\xi_n)$ произвольный элемент пространства объектов $X=R^n$, где $\xi_j=f_j(x)$.

Предположим, что признаки $f_1(x),...,f_n(x)$ являются независимыми случайными величинами.
Следовательно, функции правдоподобия классов представимы в виде:

:<tex> p_y(x) = \displaystyle\prod^n_{i=1}p_{yi}(\xi_i) </tex>

где $p_{yj}(\xi_j)$ плотность распределения значений $j$-го признака для класса $y$.
Алгоритмы классификации исходящие из этого предположения, называются ''наивными байесовскими''.

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

:<tex> a(x) = \displaystyle\arg\max_{y \in Y}(\ln\lambda_yP'_y + \sum^n_{j=1}\ln p'_{yj}(\xi_j)). </tex>

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

Основной его недостаток {{---}} низкое качество классификации в общем случае.

== Применение ==

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

Рассмотрим частое применение байесовского классификатора к задаче классификации документов по их содержимому,
а именно к классификации электронных писем на два класса {{---}} спам ($S$) и не-спам ($\displaystyle \neg S$),
предполагая что вероятность слов в тексте не зависит друг от друга:

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

:<tex> P(a\ very\ close\ game) = P(a) \times P(very) \times P(close) \times P(game) </tex>

Исходя из такого предположения, для решения задачи классификации сообщений лишь на 2 класса:
$S$ (спам) и $H = \neg S$ («хэм», то есть не спам) из теоремы Байеса можно вывести следующую формулу оценки вероятности «спамовости» всего сообщения $D$,
содержащего слова $W_1, W_2, ... W_N$:

:<tex>\displaystyle p(S\mid D) = p(S\mid W_1, W_2, ... W_N) = \frac{p(W_1, W_2, ... W_N\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = </tex> [так как $W_i$ предполагаются независимыми] <tex>=</tex>

:<tex>= \displaystyle\frac{\prod_{i} p(W_i\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = \frac{\prod_{i}p(S\mid W_i)}{\prod_i(p(S\mid W_i)) + \left(\frac{p(\neg S)}{p(S)}\right)^{1-N} \cdot \prod_i p(\neg S\mid W_i)} </tex>

Результат $p$ обычно сравнивают с некоторым порогом (например, $0.5$), чтобы решить, является ли сообщение спамом или нет. Если $p$ ниже, чем порог, сообщение рассматривают как вероятный «ham», иначе его рассматривают как вероятный спам.

:<tex>\displaystyle\ln{p(S\mid D)\over p(\neg S\mid D)} > h</tex>.

==Примеры кода==
===Пример кода scikit-learn===

Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB GaussianNB] реализует наивный байесовский классификатор в предположении что изначальное распределение было гауссовым:

:<tex> P(x_i \mid y) = \displaystyle\frac{1}{\sqrt{2\pi\sigma^2_y}}\exp(-\frac{(x_i - \mu_y)^2}{2\sigma^2_y}) </tex>

'''from''' sklearn '''import''' datasets
'''from''' sklearn.metrics '''import''' f1_score, accuracy_score
'''from''' sklearn.naive_bayes '''import''' GaussianNB
iris = datasets.load_iris()
gnb = GaussianNB()
pred = gnb.fit(iris.data, iris.target).predict(iris.data)
accuracy = accuracy_score(iris.target, pred)
f1 = f1_score(iris.target, pred, average="micro")
'''print'''(''"accruracy:"'', accuracy, ''"f1:"'', f1)

Вывод:
accruracy: 0.96 f1: 0.96

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.bayes.NaiveBayes</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/bayes/NaiveBayes.html/ Weka, Naive Bayes]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.bayes.NaiveBayes;
'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.core.converters.ConverterUtils;
'''import''' java.util.Random;

// load dataset
'''var''' source = new DataSource("/iris.arff");
'''var''' dataset = source.getDataSet();
// set class index to the last attribute
dataset.setClassIndex(dataset.numAttributes() - 1);
// create and build the classifier
'''var''' nb = new NaiveBayes();
nb.buildClassifier(dataset);
// cross validate model
var eval = new Evaluation(dataset);
eval.crossValidateModel(nb, dataset, 10, new Random(41));
System.out.println("Estimated Accuracy: "+ Double.toString(eval.pctCorrect()));

==См. также==
*[[:Байесовские сети|Байесовские сети]]
*[[:Независимые события|Независимые события]]
*[[:Формула Байеса|Формула Байеса]]

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 Википедия {{---}} Наивный байесовский классификатор]
* [http://www.machinelearning.ru/wiki/images/6/6d/Voron-ML-1.pdf К.В.Воронцов Математические методы обучения по прецедентам]
* [https://scikit-learn.org/stable/modules/naive_bayes.html Scikit-learn 1.9. Supervised learning - Naive Bayes]

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Байесовская классификация

2019-04-08T14:21:26Z

91.215.123.110:

== Вероятностная постановка задачи классификации ==

Пусть $X$ множество объектов, $Y$ конечное множество имён классов,
множество $X \times Y$ является вероятностным пространством с плотностью распределения $p(x,y)=P(y)p(x|y)$.
Вероятности появления объектов каждого из классов $P_y=P(y)$ называются ''априорными вероятностями классов''.
Плотности распределения $p_y(x)=p(x|y)$ называются ''функциями правдоподобия классов''.

'''Вероятностная постановка задачи классификации разделяется на две независимые подзадачи:'''
* Имеется простая выборка $X^l=(x_i, y_i)^l_{i=1}$ из неизвестного распределения $p(x,y)=P_yp_y(x)$. Требуется построить ''эмпирические оценки'' априорных вероятностей $P'_y$ и функций правдоподобия $p'_y(x)$ для каждого из классов $y \in Y$.
* По известным плотностям распределения $p_y(x)$ и априорным вероятностям $P_y$ всех классов $y \in Y$ построить алгоритм $a(x)$, минимизирующий вероятность ошибочной классификации.

Априорные вероятности классов $P_y$ можно оценить согласно закону больших чисел,
тогда частота появления объектов каждого из классов равна $P'_y=\frac{l_y}{l}$ где $l_y=|X^l_y|, y \in Y$
сходится по вероятности к $P_y$ при $l_y \to \infty$. Чем больше длина выборки, тем точнее выборочная оценка $P'_y$.

== Оптимальный байесовский классификатор ==

Рассмотрим произвольный алгоритм $a:X \to Y$.
Он разбивает множество $X$ на не пересекающиеся области $A_y=\{x \in X | a(x) = y\}, y \in Y$.
Вероятность того,что появится объект класса $y$ и алгоритм $a$ отнесёт его к классу $s$, равна $P_yP(A_s|y)$.
Каждой паре $(y,s) \in Y \times Y$ поставим в соответствие величину потери $\lambda_{ys}$
при отнесении объекта класса $y$ к классу $s$.

{{Определение
|definition =
'''Функционал среднего риска''' {{---}} ожидаемая величина потери при классификации объектов алгоритмом $a$:
:<tex> R(a) = \displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) </tex>
}}

{{Теорема
|about=
об оптимальности байесовского классификатора
|statement=
Если известны априорные вероятности $P_y$ и функции правдоподобия $p_y(x)$,
то минимум среднего риска $R(a)$ достигается алгоритмом
:<tex> a(x) = \displaystyle\arg\min_{s \in Y}\sum_{y \in Y}\lambda_{ys}P_yp_y(x) </tex>
|proof=

Для произвольного $t \in Y$ запишем функционал среднего риска:

:<tex> R(a)=\displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) = \sum_{y \in Y}\lambda_{yt}P_yP(A_t|y) + \sum_{s \in Y\setminus\{t\} }\sum_{y \in Y}\lambda_{ys}P_yP(A_s|y).</tex>

Применив формулу полной вероятности, $P(A_t \mid y) = 1 −\displaystyle\sum_{ s \in Y \setminus \{t\} }P(A_s \mid y)$, получим:

:<tex> R(a) = \displaystyle\sum_{y \in Y}\lambda_{yt}P_y + \sum_{ s \in Y \setminus \{t\} } \sum_{y \in Y} (\lambda_{ys} - \lambda_{yt})P_yP(A_s|y) = </tex>

:<tex> = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} } \int_{A_s}\sum_{y \in Y} (\lambda_{ys}−\lambda_{yt})P_yp_y(x)dx. </tex>

Введём для сокращения записи обозначение
$g_s(x) = \displaystyle\sum_{y \in Y}\lambda_{ys}P_yp_y(x)$, тогда
$R(a) = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} }\int_{A_s}(g_s(x)−g_t(x))dx$.

Минимум интегрла достигается, когда $A_s$ совпадает с областью неположительности подынтегрального выражения.
:<tex> A_s=\{x \in X \mid g_s(x) \leq g_t(x), \forall t \in Y, t \leq s\}. </tex>

С другой стороны, $A_s=\{x \in X \mid a(x) = s\}$. Значит, $a(x) = s$ тогда и только тогда, когда
:$s= \displaystyle\arg\min_{t \in Y}g_t(x)$.
}}

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

Допустим, что объекты $x \in X$ описываются $n$ числовыми признаками $f_j:X→R,j= 1,...,n$.
Обозначим через $x = (\xi_1,...,\xi_n)$ произвольный элемент пространства объектов $X=R^n$, где $\xi_j=f_j(x)$.

Предположим, что признаки $f_1(x),...,f_n(x)$ являются независимыми случайными величинами.
Следовательно, функции правдоподобия классов представимы в виде:

:<tex> p_y(x) = \displaystyle\prod^n_{i=1}p_{yi}(\xi_i) </tex>

где $p_{yj}(\xi_j)$ плотность распределения значений $j$-го признака для класса $y$.
Алгоритмы классификации исходящие из этого предположения, называются ''наивными байесовскими''.

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

:<tex> a(x) = \displaystyle\arg\max_{y \in Y}(\ln\lambda_yP'_y + \sum^n_{j=1}\ln p'_{yj}(\xi_j)). </tex>

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

Основной его недостаток {{---}} низкое качество классификации в общем случае.

== Применение ==

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

Рассмотрим частое применение байесовского классификатора к задаче классификации документов по их содержимому,
а именно к классификации электронных писем на два класса {{---}} спам ($S$) и не-спам ($\displaystyle \neg S$),
предполагая что вероятность слов в тексте не зависит друг от друга:

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

:<tex> P(a\ very\ close\ game) = P(a) \times P(very) \times P(close) \times P(game) </tex>

Исходя из такого предположения, для решения задачи классификации сообщений лишь на 2 класса:
$S$ (спам) и $H = \neg S$ («хэм», то есть не спам) из теоремы Байеса можно вывести следующую формулу оценки вероятности «спамовости» всего сообщения $D$,
содержащего слова $W_1, W_2, ... W_N$:

:<tex>\displaystyle p(S\mid D) = p(S\mid W_1, W_2, ... W_N) = \frac{p(W_1, W_2, ... W_N\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = </tex> [так как $W_i$ предполагаются независимыми] <tex>=</tex>

:<tex>= \displaystyle\frac{\prod_{i} p(W_i\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = \frac{\prod_{i}p(S\mid W_i)}{\prod_i(p(S\mid W_i)) + \left(\frac{p(\neg S)}{p(S)}\right)^{1-N} \cdot \prod_i p(\neg S\mid W_i)} </tex>

Результат $p$ обычно сравнивают с некоторым порогом (например, $0.5$), чтобы решить, является ли сообщение спамом или нет. Если $p$ ниже, чем порог, сообщение рассматривают как вероятный «ham», иначе его рассматривают как вероятный спам.

:<tex>\displaystyle\ln{p(S\mid D)\over p(\neg S\mid D)} > h</tex>.

==Примеры кода==
===Пример кода scikit-learn===

Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB GaussianNB] реализует наивный байесовский классификатор в предположении что изначальное распределение было гауссовым:

:<tex> P(x_i \mid y) = \displaystyle\frac{1}{\sqrt{2\pi\sigma^2_y}}\exp(-\frac{(x_i - \mu_y)^2}{2\sigma^2_y}) </tex>

'''from''' sklearn '''import''' datasets
'''from''' sklearn.metrics '''import''' f1_score, accuracy_score
'''from''' sklearn.naive_bayes '''import''' GaussianNB
iris = datasets.load_iris()
gnb = GaussianNB()
pred = gnb.fit(iris.data, iris.target).predict(iris.data)
accuracy = accuracy_score(iris.target, pred)
f1 = f1_score(iris.target, pred, average="micro")
'''print'''(''"accruracy:"'', accuracy, ''"f1:"'', f1)

Вывод:
accruracy: 0.96 f1: 0.96

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.bayes.NaiveBayes</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/bayes/NaiveBayes.html/ Weka, Naive Bayes]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.bayes.NaiveBayes;
'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.core.converters.ConverterUtils;
'''import''' java.util.Random;

// load dataset
'''var''' source = new DataSource("/iris.arff");
'''var''' dataset = source.getDataSet();
//set class index to the last attribute
dataset.setClassIndex(dataset.numAttributes() - 1);
//create and build the classifier
'''var''' nb = new NaiveBayes();
nb.buildClassifier(dataset);
// cross validate model
var eval = new Evaluation(dataset);
eval.crossValidateModel(nb, dataset, 10, new Random(41));
System.out.println("Estimated Accuracy: "+ Double.toString(eval.pctCorrect()));

==См. также==
*[[:Байесовские сети|Байесовские сети]]
*[[:Независимые события|Независимые события]]
*[[:Формула Байеса|Формула Байеса]]

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 Википедия {{---}} Наивный байесовский классификатор]
* [http://www.machinelearning.ru/wiki/images/6/6d/Voron-ML-1.pdf К.В.Воронцов Математические методы обучения по прецедентам]
* [https://scikit-learn.org/stable/modules/naive_bayes.html Scikit-learn 1.9. Supervised learning - Naive Bayes]

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Примеры кода на Java

2019-04-08T14:20:27Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);
===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)}}
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

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

2019-04-08T14:19:32Z

91.215.123.110:

'''Метрический классификатор''' (англ. similarity-based classifier) {{---}} алгоритм классификации, основанный на вычислении оценок сходства между объектами.

Для формализации понятия сходства вводится функция расстояния между объектами <tex>\rho(x,x')</tex>. Как правило, не требуется, чтобы были выполнены все три аксиомы метрики {{---}} неравенство треугольника может нарушаться.

'''Метод ближайших соседей''' {{---}} простейший метрический классификатор, основанный на оценивании сходства объектов. Классифицируемый объект относится к тому классу, которому принадлежат ближайшие к нему объекты обучающей выборки.

'''Метод <tex>k</tex> ближайших соседей''' (англ. kNN {{---}} <tex>k</tex> Nearest Neighbours) {{---}} Для повышения надёжности классификации объект относится к тому классу, которому принадлежит большинство из его соседей {{---}} <tex>k</tex> ближайших к нему объектов обучающей выборки <tex>x_i</tex>. В задачах с двумя классами число соседей берут нечётным, чтобы не возникало ситуаций неоднозначности, когда одинаковое число соседей принадлежат разным классам.

'''Метод взвешенных ближайших соседей''' {{---}} в задачах с числом классов 3 и более нечётность уже не помогает и ситуации неоднозначности всё равно могут возникать. Тогда <tex>i</tex>-му соседу приписывается вес <tex>w_i</tex>, как правило, убывающий с ростом ранга соседа <tex>i</tex>. Объект относится к тому классу, который набирает больший суммарный вес среди <tex>k</tex> ближайших соседей.

== Описание алгоритма ==
Пусть задана обучающая выборка пар "объект-ответ" <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Пусть на множестве объектов задана функция расстояния <tex>\rho(x,x')</tex>. Эта функция должна быть достаточно адекватной моделью сходства объектов. Чем больше значение этой функции, тем менее схожими являются два объекта <tex>x, x'</tex>.

Для произвольного объекта <tex>u</tex> расположим объекты обучающей выборки <tex>x_i</tex> в порядке возрастания расстояний до <tex>u</tex>:

<tex>\rho(u,x_{1; u}) \leq \rho(u,x_{2; u}) \leq \cdots \leq \rho(u,x_{m; u})</tex>,
где через <tex>x_{i; u}</tex> обозначается тот объект обучающей выборки, который является <tex>i</tex>-м соседом объекта <tex>u</tex>. Аналогичное обозначение введём и для ответа на <tex>i</tex>-м соседе: <tex>y_{i; u}</tex>. Таким образом, произвольный объект <tex>u</tex> порождает свою перенумерацию выборки. В наиболее общем виде алгоритм ближайших соседей есть:
<tex>a(u) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] w(i,u)</tex>,

где <tex>w(i,u)</tex> {{---}} заданная весовая функция, которая оценивает степень важности <tex>i</tex>-го соседа для классификации объекта <tex>u</tex>. Естественно полагать, что эта функция не отрицательна и не возрастает по <tex>i</tex> (поскольку чем дальше объект, тем меньший вклад он должен вносить в пользу своего класса).

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

<tex>w(i,u) = [i=1]</tex> {{---}} простейший метод ближайшего соседа;

<tex>w(i,u) = [i\leq k]</tex> {{---}} метод <tex>k</tex> ближайших соседей;

<tex>w(i,u) = [i\leq k] q^i</tex> {{---}} метод <tex>k</tex> экспоненциально взвешенных ближайших соседей, где предполагается константа <tex>q < 1</tex>;

[[Файл:SimpleKnnExample.png|frame|none|super|upright=1|Пример классификации, методом 5 ближайших соседей]]

== Использование ядер сглаживания ==
При использовании линейной функции в качестве <tex>w(i, u)</tex> возможно совпадение суммарного веса для нескольких классов. Это приводит к неоднозначности ответа при классификации. Чтобы такого не происходило, используют функцию [[Ядра]][на 28.01.18 не создан].

Будем обозначать функцию ядра <tex>K(r)</tex>.

=== Примеры ядер ===

Triangular: <tex>{\displaystyle K(r)=(1-|r|)}</tex>,

Parabolic: <tex>{\displaystyle K(r)={\frac {3}{4}}(1-r^{2})}</tex>,

Tricube: <tex>{\displaystyle K(r)={\frac {70}{81}}(1-{\left|r\right|}^{3})^{3}}</tex>.

=== Метод парзеновского окна ===

Алгоритм <tex>k</tex> ближайших соседей можно обобщить с помощью функции ядра. Рассмотрим два способа, которыми это можно сделать.

<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex> {{---}} метод парзеновского окна фиксированной ширины <tex>h</tex>;

<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex> {{---}} метод парзеновского окна переменной ширины;

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

Фиксированной ширины: <tex>a_h = a(u, X^m, \boldsymbol{h}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex>,

Переменной ширины: <tex>a_k = a(u, X^m, \boldsymbol{k}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex>.

<tex>a_h</tex> не будет учитывать соседей на расстояние больше чем <tex>h</tex>, а всех остальных учтет в соответствии с функций ядра <tex>K</tex>.
<tex>a_k</tex> является аналогом метода <tex>k</tex> ближайших соседей (т.к. для всех <tex>k+i</tex>-ых соседей функция <tex>K</tex> вернет 0), но при этом чем ближе <tex>k-i</tex>-ый сосед, тем больший вклад в сторону своего класса он даст.

Часто используют окно переменной ширины т.е. классификатор <tex>a_k</tex>, по следующим причинам:

# Удобнее оптимизировать целочисленный параметр <tex>k</tex>, чем вещественный параметр <tex>h</tex> по некоторой сетке;

# Существует большое количество задач, где точки разбросаны неравномерно. В них могут существовать области, где достаточно брать небольшую <tex>h</tex> и области, где в окно ширины <tex>h</tex> попадает только одна точка. Тогда для классификатора <tex>a_h</tex> будут существовать области в которых не будет ни одного объекта (кроме того, который нужно классифицировать). Для таких областей не понятно как классифицировать объекты.

[[Файл:KnnExample.png|frame|none|super|upright=1|Пример классификации, методом с постоянной шириной окна, и неравномерным разбросом точек]]

== Использование различных метрик расстояния ==
Очень редко известна хорошая функция расстояния <tex>\rho(x,x')</tex>. В качестве нее обычно использую следующие функции:

=== Примеры метрик ===
Пусть <tex>x</tex>, <tex>y</tex> {{---}} объекты, а <tex>(x_1, x_2,..., x_n)</tex>, <tex>(y_1, y_2,..., y_n)</tex> их признаковые описания.

Евклидова метрика: <tex>\rho(x,y) = \sqrt {\sum _{i=1}^{n}(x_{i}-y_{i})^{2}}</tex>,

Расстояние Чебышёва: <tex>\rho(x,y)=\max _{i=1,\dots ,n}|x_{i}-y_{i}|</tex>,

Манхэттенское Расстояние: <tex>\rho(x,y)=\sum _{i=1}^{n}|x_{i}-y_{i}|</tex>.

При их использовании важно нормировать значения признаков, иначе один признак с максимальным значением может стать преобладающим, а признаки с маленькими значениями не будут учитываться при классификации. Чтобы отсеять лишние признаки (т.е. не влияющие на класс объекта) можно использовать [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8 feature selection].

== Пример использования (через scikit-learn) ==

Рассмотрим использование алгоритма <tex>kNN</tex> на примере [https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29 реального набора данных].
Предположим, что мы загрузили <tex>wdbc.data</tex> и сохранили как <tex>tr.csv</tex> с заголовком {{---}} описанием признаков.

* Загружаем данные

'''import''' pandas '''as''' pd
'''from''' sklearn.preprocessing '''import''' StandardScaler

'''def''' load_data(data_path):
ds = pd.read_csv(data_path, names=["id", "diagnosis", "radius_mean", "texture_mean", "perimeter_mean", "area_mean",
"smoothness_mean", "compactness_mean", "concavity_mean", "concave points_mean",
"symmetry_mean", "fractal_dimension_mean", "radius_se", "texture_se",
"perimeter_se", "area_se", "smoothness_se", "compactness_se", "concavity_se",
"concave points_se", "symmetry_se", "fractal_dimension_se", "radius_worst",
"texture_worst", "perimeter_worst", "area_worst", "smoothness_worst",
"compactness_worst", "concavity_worst", "concave points_worst", "symmetry_worst",
"fractal_dimension_worst"])
y = ds['diagnosis']
X = ds.drop('diagnosis', axis=1)
X = X.drop('id', axis=1)
i = len(X.columns)
X = X.drop(X.columns[i - 1], axis=1)
y.replace(('M', 'B'), (1, 0), inplace=True)
sc = StandardScaler()
sc.fit(X)
X_ans = sc.transform(X)
return X_ans, y

X, y = load_data("tr.csv")

Теперь <tex>X</tex>, <tex>y</tex> {{---}} нормированные значения признаков и соответствующие им классы.

* Делим данные на тренировочное и тестовое множество:
'''from''' sklearn.model_selection '''import''' train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)

* Создаем классификатор:
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier

best_model = KNeighborsClassifier(
'''n_neighbors'''=10,
'''weights'''=’distance’,
'''algorithm'''=’auto’,
'''leaf_size'''=30,
'''metric'''=’euclidean’,
'''metric_params'''=None,
'''n_jobs'''=4
)

* Обучаемся:

best_model.fit(X_train, y_train)

* Используем скользящий контроль для поиска лучших параметров (англ. cross validation):
'''from''' sklearn.model_selection '''import''' GridSearchCV

model_params = best_model.get_params()
tuned_params = {}
for k, v in model_params.items():
tuned_params[k] = [v]
tuned_params['n_neighbors'] = range(1, 30)
clf = GridSearchCV(KNeighborsClassifier(), tuned_params, cv=10, n_jobs=-1)
clf.fit(X_train, y_train)
best_params = clf.best_params_

* Оценка классификатора:
'''from''' sklearn '''import''' metrics

best_model = KNeighborsClassifier(**best_params)
best_model.fit(X_train, y_train)
predicted = best_model.predict(X_test)

* Выводим результат:
print('Used params:', best_params)
print('Evaluation:\n', metrics.classification_report(y_test, predicted))

> '''Used params''': {'metric_params': None, 'metric': 'euclidean', 'weights': 'distance', 'n_neighbors': 9, 'leaf_size': 30, 'n_jobs': 4, 'p': 2, 'algorithm': 'auto'}
'''Evaluation:'''
precision recall f1-score support
0 0.90 1.00 0.95 69
1 1.00 0.82 0.90 45
micro avg 0.93 0.93 0.93 114
macro avg 0.95 0.91 0.92 114
weighted avg 0.94 0.93 0.93 114

==Пример на языке Scala==
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.knn<ref>[https://haifengl.github.io/smile/classification.html#knn Smile, KNN]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''toy: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = toy.x()
'''val '''y: Array['''Int'''] = toy.y().map(_.toInt)
'''val '''KNN: KNN[Array['''Double''']] = knn(x, y, 3)
'''val '''predictions: Array['''Int'''] = x.map(KNN.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, KNN)

==Пример на языке Java==
Пример классификации датасета с применением <code>weka.classifiers.lazy.IBk</code><ref>[http://weka.sourceforge.net/doc.stable-3-8/weka/classifiers/lazy/IBk.html/ Weka, KNN]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.Evaluation;
'''import''' weka.classifiers.lazy.IBk;
'''import''' weka.core.converters.ConverterUtils;

// read dataset and build knn-classifier
'''var''' source = new ConverterUtils.DataSource("iris.csv");
'''var''' dataset = source.getDataSet();
'''var''' ibk = new IBk();
ibk.buildClassifier(dataset);
// test the model
'''var''' eTest = new Evaluation(dataset);
eTest.evaluateModel(ibk, dataset);
// print results summary
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

== См. также ==
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Примечания ==
<references/>

== Источники информации ==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 machinelearning.ru {{---}} Метрический классификатор]
* [http://www.machinelearning.ru/wiki/index.php?title=KNN machinelearning.ru {{---}} Метод ближайших соседей (kNN)]
* [https://www.youtube.com/watch?v=l1xGQMowWA4&t=0s&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=3 Лекция "Метрические методы классификации" К.В. Воронцов, курс "Машинное обучение" 2014]
* [https://en.wikipedia.org/wiki/Kernel_(statistics) Wikipedia {{---}} Kernel (statistics)]
* [https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html Документация по scikit-learn]
* [https://www.kaggle.com/jeffbrown/knn-classifier/data Пример по работе с датасетом с kaggle]

[[Категория: Машинное обучение]]
[[Категория: Метрический классификатор]]

Обзор библиотек для машинного обучения на Python

2019-04-08T14:18:35Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price)
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);
===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

// read train & test datasets and build MLP classifier
'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)}}
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Бустинг, AdaBoost

2019-04-08T14:05:29Z

91.215.123.110:

==Описание==
'''Бустинг''' (англ. ''boosting'') {{---}} [[Мета-обучение|мета-алгоритм машинного обучения]]. Основной идеей бустинга является комбинирование слабых функций, которые строятся в ходе итеративного процесса, где на каждом шаге новая модель обучается с использованием данных об ошибках предыдущих. Сильный обучающий алгоритм является классификатором, хорошо [[Корреляция случайных величин|коррелирующим]] с верной классификацией, в отличие от слабого. Наравне с бустингом в мета-обучении также рассматривают такие понятия, как [[Виды ансамблей|бэггинг]] (англ. ''bagging'') и стэкинг<ref>[https://dyakonov.org/2017/03/10/c%D1%82%D0%B5%D0%BA%D0%B8%D0%BD%D0%B3-stacking-%D0%B8-%D0%B1%D0%BB%D0%B5%D0%BD%D0%B4%D0%B8%D0%BD%D0%B3-blending/#more-4558 Стекинг {{---}} Дьяконов Александр]</ref> (англ. ''stacking''). Бэггинг, в отличии от бустинга, использует параллельное обучение базовых классификаторов. Стэкинг же комбинирует результаты различных алгоритмов, получая тем самым более точный ответ.

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

==Алгоритмы бустинга==
{{Определение
|definition='''Композицией''' $T$ '''алгоритмов''' <tex>a_t(x) = C(b_t(x)),\ t = 1,...,T</tex> называется [[Суперпозиции|суперпозиция]] алгоритмических операторов <tex>b_t\ :\ X\to R</tex>, корректирующей операции <tex>F\ :\ R^T\to R</tex> и решающего правила <tex> C\ :\ R\to Y</tex>, где <tex>R</tex> {{---}} пространство оценок, <center><tex>a(x) = C(F(b_1(x),...,b_T(x))), x \in X</tex></center> , Алгоритмы $a_t$ называют ''базовыми алгоритмами''.}}
Бустинг представляет собой композицию алгоритмов, в которых ошибки отдельных алгоритмов взаимно компенсируются. Например, в задаче классификации на два класса $Y = {-1, +1}$ в качестве пространства оценок принимают $R = \mathbb{R}$ и <tex>C(b(x)) = \textrm{sign}(b(x))</tex>. Тогда базовые алгоритмы возвращают ответы $−1, 0, +1$. Ответ $b_t(x) = 0$ означает, что базовый алгоритм $b_t$ отказывается от классификации объекта $x$, и ответ $b_t(x)$ не учитывается в композиции. Получаем искомую композицию:
<center><tex>a(x) = C(F(b_1(x),...,b_T(x))) = \textrm{sign}\left(\sum\limits_{t=1}^T \alpha_t b_t(x)\right),\ x\in X</tex></center>,

Большая часть алгоритмов бустинга основывается на итеративном обучении слабых классификаторов с дальнейшей сборкой их в сильный классификатор. Когда они добавляются, им обычно приписываются веса, обычно связанные с [[Общие понятия|точностью обучения]]. После добавления слабого классификатора, веса пересчитываются ('''«пересчёт весовых коэффициентов»'''). Неверно классифицированные входные данные получают больший вес, а правильно классифицированные экземпляры теряют вес. Таким образом, дальнейшее слабое обучение фокусируется на примерах, где предыдущие слабые обучения дали ошибочную классификацию.

Основное расхождение между многими алгоритмами бустинга заключается в методах определения весовых коэффициентов точек [[Общие понятия|тренировочных данных]] и гипотез. Первым алгоритмом, который смог адаптироваться к слабому обучению был '''AdaBoost'''<ref>[http://rob.schapire.net/papers/explaining-adaboost.pdf Explaining AdaBoost {{---}} Robert E. Schapire]</ref> (сокр. ''Adaptive Boosting''), предложенный Шапире и Фройндом.

Алгоритмы бустинга могут использовать выпуклую или невыпуклую функцию потерь. Алгоритмы с выпуклой функцией, такие как AdaBoost и LogitBoost<ref>[https://en.wikipedia.org/wiki/LogitBoost Wikipedia {{---}} LogitBoost]</ref>, могут некорректно классифицировать из-за случайного шума, так как не могут обучить базовым и поддающимся научению комбинациям слабых гипотез. Алгоритмы бустинга, основанные на невыпуклой функции потерь, такие как BrownBoost<ref>[https://ru.wikipedia.org/wiki/BrownBoost Википедия {{---}} BrownBoost]</ref>, позволяют избежать переобучения на данных с большим количеством "шума", откидывая зашумленные элементы.

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

Классификация признаков является типичной задачей компьютерного зрения, где определяется, содержит ли изображение некоторую категорию объектов или нет. Идея тесно связана с распознаванием, идентификацией и обнаружением. Классификация по обнаружению объекта обычно содержит выделение [[Общие понятия|признаков]], обучение классификатора и применение классификатора к новым данным. Есть много способов представления категории объектов, например по анализу формы, с помощью модели '''«мешок слов»''', с помощью локальных описателей, таких как '''SIFT'''<ref>[https://en.wikipedia.org/wiki/Scale-invariant_feature_transform Wikipedia {{---}} Scale-invariant feature transform]</ref>, и так далее. Примерами классификаторов с учителем служат наивные [[Байесовская классификация|байесовские классификаторы]][на 28.01.19 не создан], [[Метод опорных векторов (SVM)|методы опорных векторов]][на 28.01.19 не создан], смесь гауссиан и [[Нейронные сети, перцептрон|нейронные сети]]. Однако исследования показали, что категории объектов и их положение в изображениях могут быть обнаружены также с помощью обучения без учителя.

===Задача ранжирования выдачи поисковых систем===
Благодаря AdaBoost в мире появился [[CatBoost|градиентный бустинг]] (англ. ''gradient boosting'') или GBM. Задачу ранжирования выдачи поисковых запросов рассмотрели с точки зрения функции потерь, которая штрафует за ошибки в порядке выдачи, поэтому было удобно внедрить GBM в ранжирование.

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

AdaBoost вызывает слабые классификаторы <tex>h_i^t</tex> в цикле <tex>t = 1,...,T</tex>. После каждого вызова обновляется распределение весов <tex>D_t</tex>, которые отвечают важности каждого из объектов обучающего множества для классификации. На каждой итерации веса каждого неверно классифицированного объекта возрастают, таким образом новый комитет классификаторов «фокусирует своё внимание» на этих объектах.

===Описание алгоритма===

//<tex>x_i \in X, y_i \in Y = \{-1,+1\}, size(x) = size(y) = m</tex>
'''function''' AdaBoost($X$, $Y$, $m$):
//Инициализируем
'''for''' i = 1..m '''do''':
<tex>D_i^1 = \frac{1}{m}</tex>
'''end''' '''for'''

'''for''' t = 1..T '''do''':
<tex>h_t = \arg \min\limits_{h_j \in \mathcal{H}} \epsilon_j = \sum\limits_{i=1}^{m} D_i^t〚y_i\neq h_j(x_i)〛</tex> //$\epsilon$ {{---}} Взвешенная ошибка классификации, классификатор <tex>h_t:X\to \{-1,+1\}</tex>
<tex>\alpha_t = \frac{1}{2}\ln\frac{1-\epsilon_t}{\epsilon_t}</tex>
'''for''' i = 1..m '''do''':
//<tex>Z_t</tex> {{---}} нормализующий параметр, выбранный так, чтобы <tex>D^{t+1}</tex> являлось распределением вероятностей, то есть <tex>\sum\limits_{i-1}^{m} D_i^{t+1} = 1</tex>, для <tex>t=1,...,T</tex>
<tex>D_i^{t+1} = \dfrac{D_i^t \textrm{exp}(-\alpha_t y_i h_t(x_i))}{Z_t}</tex>
'''end''' '''for'''
'''end''' '''for'''
<tex>H(x) = \textrm{sign}\left(\sum\limits_{t=1}^{T} \alpha_t h_t(x)\right)</tex> //$H(x)$ {{---}} результирующий классификатор
'''return''' $H$
Выражение для обновления распределения <tex>D^t</tex> должно быть сконструировано таким образом, чтобы выполнялось условие:
<center><tex>\exp^{\alpha_t y_i h_t(x_i)} \begin{cases}<1,\ y(i) = h_t(x_i) \\ >1,\ y(i) \neq h_t(x_i)\end{cases}</tex></center>,

Таким образом, после выбора оптимального классификатора <tex>h_t</tex> для распределения <tex>D^t</tex>, объекты <tex>x_i</tex>, которые классификатор <tex>h_t</tex> идентифицирует корректно, имеют веса меньшие, чем те, которые идентифицируются некорректно. Следовательно, когда алгоритм тестирует классификаторы на распределении <tex>D^{t+1}</tex>, он будет выбирать классификатор, который лучше идентифицирует объекты неверно распознаваемые предыдущим классификатором.

===Пример работы===
Рассмотрим набор данных, которые пометим как $-$ и $+$.
[[Файл:Adaboost1.jpg|600px|thumb|center|Результат после первой итерации]]
Для всех ошибочно классифицированных объектов увеличим веса, а для верно классифицированных уменьшим
[[Файл:Adaboost2.jpg|1000px|thumb|center|Результат после пересчета весов и второй итерации]]
Рассмотрим результат после $2$-х итераций:
[[Файл:Adaboost_result12.jpg|1000px|thumb|center|Итоговый результат после $2$-х итераций]]
Как видно из последнего изображения, все, что находиться в "цветной" зоне, мы можем однозначно классифицировать, но тогда у нас появляются ошибки и "белые" зоны, которые мы не можем однозначно классифицировать. Рассмотрим алгоритм после $30$-ти итераций:
[[Файл:Adaboost_resultfinal.jpg|300px|thumb|center|Результат работы алгоритма после $30$-ти итераций]]
Теперь у нас все объекты классифицируются верно и число ошибок на выборке равно нулю.

===Достоинства и недостатки===
'''Достоинства:'''
# Простота реализации;
# Хорошая обобщающая способность. В реальных задачах удаётся строить композиции, превосходящие по качеству базовые алгоритмы. Обобщающая способность может улучшаться по мере увеличения числа базовых алгоритмов;
# Время построения композиции практически полностью определяется временем обучения базовых алгоритмов;
# Возможность идентифицировать выбросы. Это наиболее «трудные» объекты $x_i$, для которых в процессе наращивания композиции веса $w_i$ принимают наибольшие значения.
'''Недостатки:'''
# Склонен к переобучению при наличии значительного уровня шума в данных;
# Требует достаточно длинных обучающих выборок. Другие методы линейной коррекции, в частности, бэггинг, способны строить алгоритмы сопоставимого качества по меньшим выборкам данных.

===Пример кода на python для scikit-learn===
Классификатор sklearn.ensemble.'''AdaBoostClassifier'''<ref>[https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html Документация AdaBoostClassifier]</ref> имеет 5 параметров: '''base_estimator''', '''n_estimators''', '''learning_rate''', '''algorithm''', '''random_state'''.
Наиболее важными являются:
# '''base_estimator''' {{---}} базовый алгоритм. По умолчанию используется DecisionTreeClassifier(max_depth=1);
# '''n_estimators''' {{---}} максимальное количество оценок, после которого бустинг прекращается. Если произойдет полное совпадение, то закончится раньше;
# '''learning_rate''' {{---}} вклад каждой модели в весовые коэффициенты и значение по умолчанию равно $1$. Снижение этого параметра будет означать, что весовые коэффициенты буду увеличиваться или уменьшаться в небольшой степени, вынуждая модель дольше обучаться (но иногда повышается производительность).

'''from''' sklearn.ensemble '''import''' AdaBoostClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split
'''from''' sklearn '''import''' metrics

iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

abc = AdaBoostClassifier(n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.8888888888888888

Теперь рассмотрим алгоритм с SVC в качестве базы:
'''from''' sklearn.svm '''import''' SVC

svc=SVC(probability='''True''', kernel=''''linear'''')

abc = AdaBoostClassifier(base_estimator='''svc''', n_estimators='''50''', learning_rate='''1''')

model = abc.'''fit'''(X_train, y_train)

y_pred = model.'''predict'''(X_test)

'''print'''("Accuracy:",metrics.'''accuracy_score'''(y_test, y_pred))

Accuracy: 0.9555555555555556

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.adaboost<ref>[https://haifengl.github.io/smile/classification.html#adaboost Smile, AdaBoost]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''ada: AdaBoost = adaboost(x, y, ntrees = 500, maxNodes = 2)
'''val '''predictions: Array['''Int'''] = x.map(ada.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, ada)

===Пример на языке Java===
Пример классификации с применением <code>smile.classification.AdaBoost</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/AdaBoost.html/ Smile, AdaBoost]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.AdaBoost;
'''import''' smile.data.parser.ArffParser;
'''import''' smile.validation.Accuracy;
'''import''' smile.validation.ClassificationMeasure;
'''import''' smile.validation.FMeasure;
'''import''' java.util.Arrays;

// load train and test datasets
'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(0);
'''var''' train = arffParser.parse(this.getClass().getResourceAsStream("train.arff"));
'''var''' test = arffParser.parse(this.getClass().getResouceAsStream("test.arff"));
// create adaboost classifier
'''var''' forest = new AdaBoost(train.attributes(), train.x(), train.labels(), 200, 4);
// measure accuracy and F1-measure on test dataset
'''var''' measures = new ClassificationMeasure[]{new FMeasure(), new Accuracy()};
'''var''' results = forest.test(test.x(), test.labels(), measures);
System.out.println(Arrays.deepToString(results));

== См. также ==
*[[Метод опорных векторов (SVM)|Метод опорных векторов]][на 28.01.19 не создан]
*[[Байесовская классификация|Байесовская классификация]][на 28.01.19 не создан]
*[[Мета-обучение|Мета-обучение]]
*[[Нейронные сети, перцептрон|Нейронные сети]]
*[[Оценка качества в задаче кластеризации|Оценка качества в задаче кластеризации]]
*[[CatBoost|CatBoost]]

== Примечания==
<references />

== Источники информации ==
# [http://www.machinelearning.ru/wiki/index.php?title=AdaBoost AdaBoost] {{---}} статья на machinelearning.ru
# [http://cmp.felk.cvut.cz/~sochmj1/adaboost_talk.pdf AdaBoost] {{---}} презентация по AdaBoost
# [https://ru.coursera.org/lecture/ml-classification/example-of-adaboost-in-action-um0cX Example of AdaBoost in action] {{---}} презентация на coursera.org
# [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_(%D0%BA%D1%83%D1%80%D1%81_%D0%BB%D0%B5%D0%BA%D1%86%D0%B8%D0%B9%2C_%D0%9A.%D0%92.%D0%92%D0%BE%D1%80%D0%BE%D0%BD%D1%86%D0%BE%D0%B2) Курс лекций по машинному обучению] {{---}} Воронцов К.В.
[[Категория: Автоматическое машинное обучение]]
[[Категория: Машинное обучение]]
[[Категория: Ансамбли]]

Дерево решений и случайный лес

2019-04-08T14:05:05Z

91.215.123.110:

Дерево решений {{---}} логический алгоритм классификации, решающий задачи классификации и регрессии. Представляет собой объединение логических условий в структуру дерева.

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

{{Определение
|id=def1.
|neat =
|definition=
'''Дерево решений''' (англ. ''decision tree, DT'') {{---}} алгоритм классификации <tex>a(x) = (V_{внутр}, v_0, V_{лист}, S_v, \beta_v)</tex>, задающийся деревом (связным ациклическим графом), где:
* <tex> V = V_{внутр} \cup V_{лист} </tex> {{---}} множество вершин , <tex>v_0 \in V</tex> {{---}} корень дерева;
* <tex> S_v : D_v \rightarrow V_v </tex> {{---}} функция перехода по значению предиката в множество детей вершины <tex>v</tex>;
* <tex> \beta_v : X \rightarrow D_v </tex> {{---}} предикат ветвления, <tex>v \in V_{внутр}</tex> и <tex>|D_v| < \infty</tex>;
* Для листьев <tex>v \in V_{лист}</tex> определена метка класса <tex>y_v \in Y</tex>.
}}
{{Определение
|id=def1
|neat =
|definition=
'''Бинарное дерево решений''' {{---}} частный случай дерева решений, для которого <tex> D_v = \{0,1\} </tex>.
}}
[[Файл:BinDT.jpg |300px|thumb|right|Классификация объекта <tex> x \in X </tex> бинарным решающим деревом]]

'''function''' classify(x):
<tex>v = v_0</tex>
'''if''' <tex>\beta_v(x) = 1 </tex>
<tex>v := R_v</tex>
'''else'''
<tex>v := L_v</tex>
'''return''' <tex>y_v</tex>

===Информативность ветвления===
Для того, чтобы оценивать качество разбиения объектов по предикату <tex>\beta</tex>, введем понятие ''информационного выигрыша'' разбиения. 
Сначала оценим распределение значений классов объектов внутри каждого множества из разбиения, введя понятие ''меры неопределенности распределения''.
{{Определение
|id=def1
|neat =
|definition=
'''Частотная оценка вероятности класса <tex>y</tex> в вершине <tex>v \in V_{внутр}</tex> ''': 
<tex>p_y = P(y | x \in U) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}[y_i = y]</tex>
}}

{{Определение
|id=def1
|neat =
|definition=
'''Мера неопределенности (англ. ''impurity'') распределения <tex>p_y</tex>''': 
* минимальна, когда <tex>p_y \in \{0,1\}</tex>;
* максимальна, когда <tex>p_y = \frac{1}{|Y|}</tex> для всех <tex>y \in Y</tex>;
* не зависит от перенумерации классов
<tex>Ф(U) = \sum\nolimits_{y \in Y} p_y L(p_y) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}L(P(y_i | x_i \in U)) \rightarrow min</tex>, где <tex>L(p)</tex> убывает и <tex>L(1) = 0</tex>, например: <tex>-log_2(p)</tex>, <tex>1 - p</tex>, <tex>1 - p^2</tex>
}}

Примерами мер неопределенности распределения являются:
* Энтропия: <tex>Ф(U) = -\sum\limits_{i}^N p_i log_2p_i</tex>, определяется для каждого множества из разбиения, <tex>N</tex> {{---}} количество возможных классов, и <tex>p_i</tex> {{---}} вероятность объекта принадлежать <tex> i</tex>-ому классу.
* Критерий Джини: <tex>Ф(U) = \sum\nolimits_{i != j}p_i p_j = \sum\nolimits_{i}p_i*(1-p_i)</tex>, максимизацию этого критерия можно интерпретировать как максимизацию числа пар объектов одного класса, оказавшихся после разбиения в одном множестве. 

Теперь определим суммарную ''неопределенность распределения'' в разбиении.
{{Определение
|id=def1
|neat =
|definition=
'''Неопределенность распределения <tex>P(y_i | x_i \in U_{\beta(x_i)})</tex> после ветвления вершины <tex>v</tex> по предикату <tex>\beta</tex> и разбиения <tex>U = \bigcup_{k \in D_v} U_k</tex>''': 
<tex>Ф(U_0, ... ,U_{D_v}) = \frac{1}{|U|} \sum\nolimits_{k \in D_v} \sum\nolimits_{x_i \in U_k}L(P(y_i | x_i \in U_k)) = \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k)</tex>
}}

''Информационный выигрыш'' от разбиения определяется как изменение неопределенности в системе.
{{Определение
|id=def1
|neat =
|definition=
'''Информационный выигрыш от разбиения по предикату <tex>\beta</tex>''' 
<tex>Gain(\beta, U) = Ф(U) - Ф(U_1, ... ,U_{|D_v|}) = Ф(U) - \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k) \rightarrow max_{\beta \in B} </tex>
}}

=== Рекурсивный алгоритм построения бинарного дерева решений ID3 ===
Покажем идею построения дерева решения на частном случае бинарного дерева. Алгоритм <tex>ID3</tex> (англ. ''Induction of Decision Tree'') заключается в последовательном дроблении выборки на две части до тех пор, пока в каждой части не окажутся объекты только одного класса. Разделение производится по предикату <tex>\beta</tex>, который выбирается из множества элементарных предикатов. На практике в качестве элементарных предикатов чаще всего берут простые пороговые условия вида <tex>\beta(x) = [f_j(x) >= d_j]</tex>.
 Проще всего записать этот алгоритм в виде рекурсивной процедуры <tex>ID3</tex>, которая строит дерево по заданной подвыборке <tex>U</tex> и возвращает его корневую вершину.

1:'''function''' ID3(<tex>U</tex>):
2: '''if''' <tex>for all</tex> <tex>u \in U</tex>: <tex>y_u = y</tex>, <tex>y \in Y</tex>
// создать листовую вершину <tex>v</tex> c меткой класса <tex>y_v</tex> 
3: v = createLeafVertex(<tex>y_v</tex>)
4: '''return''' v
// найти предикат с максимальным информационным выигрышом 
<tex>\beta= \mathrm{arg}\max_{\beta\in B} </tex> Gain(<tex>\beta</tex>, <tex>U</tex>)
// разбить выборку на две части <tex>U = U_0 \cup U_1</tex> по предикату <tex>\beta</tex> 
5: <tex>U_0 := \{x \in U: \beta(x) = 0\}</tex>
6: <tex>U_1 := \{x \in U: \beta(x) = 1\}</tex>
7: '''if''' <tex>U_0 = \emptyset</tex> || <tex>U_1 = \emptyset</tex>
// найти класс, в котором находится большинство объектов из <tex>U</tex> 
8: <tex>y_v</tex> = majorClass(<tex>U</tex>)
9: v = createLeafVertex(<tex>y_v</tex>)
'''else'''
// создать внутреннюю вершину <tex>v</tex>
10: v = createVertex()
11: <tex>\beta_v = \beta</tex>
12: <tex>S_0</tex> = ID3(<tex>U_0</tex>)
13: <tex>S_1</tex> = ID3(<tex>U_1</tex>)
14: '''return''' <tex>v</tex>

== Редукция решающих деревьев ==
Суть редукции (англ. ''pruning'') состоит в удалении поддеревьев, имеющих недостаточную статистическую надёжность. При этом дерево перестаёт безошибочно классифицировать обучающую выборку, зато качество классификации новых объектов, как правило, улучшается. Рассмотрим наиболее простые варианты редукции.

===Предредукция===
Предредукция (англ. ''pre-pruning'') или критерий раннего останова досрочно прекращает дальнейшее ветвление в вершине дерева, если информативность <tex>I(\beta, U)</tex> для всех возможных предикатов <tex>\beta</tex> не дотягивает до заданного порогового значения <tex>I_0</tex>. 
Для этого на шаге 8 алгоритма <tex>ID3</tex> условие <tex>U_0 = \emptyset</tex> или <tex>U_1 = \emptyset</tex> заменяется условием <tex>I(\beta, U) <= I_0 </tex>. Порог <tex>I_0 </tex> является управляющим параметром метода. 
Предредукция считается не самым эффективным способом избежать переобучения, так как жадное ветвление по-прежнему остаётся глобально неоптимальным. Более эффективной считается cтратегия постредукции.

===Постредукция===
Постредукция (англ. ''post-pruning'') просматривает все внутренние вершины дерева и заменяет отдельные вершины либо одной из дочерних вершин (при этом вторая дочерняя удаляется), либо терминальной вершиной. Процесс замен продолжается до тех
пор, пока в дереве остаются вершины, удовлетворяющие критерию замены. 
''Критерием замены'' является сокращение числа ошибок на контрольной выборке, отобранной заранее, и не участвовавшей в обучении дерева. Стандартная рекомендация — оставлять в контроле около 30% объектов. 
Для реализации постредукции контрольная выборка <tex>X^k</tex> пропускается через
построенное дерево. При этом в каждой внутренней вершине <tex>v</tex> запоминается подмножество <tex>S_v \subseteq X_k</tex> попавших в неё контрольных объектов. Если <tex>S_v = \emptyset </tex>, то вершина <tex>v</tex> считается ненадёжной и заменяется терминальной по ''мажоритарному правилу'': 
в качестве <tex>y_v</tex> берётся тот класс, объектов которого больше всего в обучающей подвыборке <tex>U</tex>, пришедшей в вершину <tex>v</tex>. 
Затем для каждой внутренней вершины <tex>v</tex> вычисляется число ошибок, полученных при классификации выборки <tex>S_v</tex> следующими способами: 
* <tex>r(v)</tex> — классификация поддеревом, растущим из вершины <tex>v</tex>;
* <tex>r_L(v)</tex> — классификация поддеревом левой дочерней вершины <tex>L_v</tex>;
* <tex>r_R(v)</tex> — классификация поддеревом правой дочерней вершины <tex>R_v</tex>;
* <tex>r_c(v)</tex> — отнесение всех объектов выборки <tex>S_v</tex> к классу <tex>y \in Y</tex>. 
Эти величины сравниваются, и в зависимости от того, какая из них оказалась
минимальной, принимается, соответственно, одно из четырёх решений: 
* сохранить поддерево вершины <tex>v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом левой дочерней вершины <tex>L_v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом правой дочерней вершины <tex>R_v</tex>;
* заменить поддерево <tex>v</tex> терминальной вершиной класса <tex>y_v = \mathrm{arg}\min_{y\in Y}r_c(v) </tex>.

== Алгоритмы построения деревьев решения ==
Недостатки рассмотренного алгоритма ID3:
* Применим только для дискретных значений признаков;
* Переобучение;
* На каждом шаге решение принимается по одному атрибуту.

=== Алгоритм [https://en.wikipedia.org/wiki/Predictive_analytics#Classification_and_regression_trees_.28CART.29 CART] (англ. ''Classification And Regression Trees'')===
* В отличие от ID3 работает и с непрерывными значениями признаков: на каждом шаге построения дерева последовательно сравнивает все возможные разбиения для всех атрибутов и выбирает наилучший атрибут и наилучшее разбиение для него. Разбивает объекты на две части;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

=== Алгоритм [https://en.wikipedia.org/wiki/C4.5_algorithm C4.5] ===
* Также работает и с непрерывными значениями признаков: на каждом шаге построения дерева выбирает правило разбиения по одному из признаков. Разбивает объекты на несколько частей по этому правилу, рекурсивно запускается из полученных подмножеств;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

== Случайный лес ==
Случайный лес {{---}} один из примеров объединения классификаторов в [[Виды_ансамблей|ансамбль]]. 
Алгоритм построения случайного леса, состоящего из <tex>N</tex> деревьев на основе обучающей выборки <tex>X</tex> такой:
'''for''' (n: 1,...,N):
// сгенерировать выборку <tex>X_n</tex> c помощью [[Виды_ансамблей#Бутстрэп|бутстрэпа]]
<tex>X_n</tex> = bootstrap(<tex>X</tex>)
// построить решающее дерево <tex>t_n</tex> по выборке <tex>X_n</tex>
<tex>t_n</tex> = ID3(<tex>X_n</tex>) 

Итоговый классификатор {{---}} <tex>a(x) = \frac{1}{N} \sum\limits_{i = 1}^{N} t_i(x)</tex>. Для задачи классификации мы выбираем решение по большинству результатов, выданных классификаторами, а в задаче регрессии {{---}} по их среднему значению. 

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

==Примеры кода==
===Примеры на языке Python===
*Для решения задач классификации и регрессии используют [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier DecisionTreeClassifier], [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html#sklearn.tree.DecisionTreeRegressor DecisionTreeRegressor];

*В '''sklearn.ensemble''' также представлены методы классификации, основанные на ансамблях, в том числе: [https://scikit-learn.org/stable/modules/ensemble.html#bagging бэггинг] и [https://scikit-learn.org/stable/modules/ensemble.html#forest случайный лес], которые были описаны выше.
 Так, в этом примере создается бэггинг ансамбль из классификаторов '''KNeighborsClassifier''', каждый из которых обучен на случайных подмножествах из 50% объектов из обучающей выборки, и 50% случайно выбранных признаков.

'''from''' sklearn.ensemble '''import''' BaggingClassifier
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier
bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)

Пример использования классификатора на случайном лесе:
Полную версию кода можно найти [https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-download-auto-examples-classification-plot-classifier-comparison-py| здесь]
'''from''' sklearn '''import''' RandomForestClassifier
'''from''' sklearn.datasets '''import''' make_classification
// сгенерируем случайную обучающую выборку с классификацией по n_classes классам
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=2)
// разбиваем выборку на обучающую и тестовую 
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
// создадим классификатор на случайном лесе, состоящим из n_estimators деревьев
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)

Результат классификации показан на рисунке.

[[Файл:RFC.png |800px|thumb|center|Классификация RandomForestClassifier. Кружочками изображены объекты обучающей выборки, крестиками тестовой выборки. Справа цветом выделены границы принятия решений, в правом нижнем углу {{---}} значение accuracy.]]

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.cart<ref>[https://haifengl.github.io/smile/classification.html#cart Smile, Decision Trees]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''dt: DecisionTree = cart(x, y, 1000)
'''val '''predictions: Array['''Int'''] = x.map(dt.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, dt)

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.trees.RandomForest</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/trees/RandomForest.html Weka, Random Forest]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.classifiers.trees.RandomForest;

// read dataset
'''var''' trainingDataSet = getDataSet(...);
'''var''' testingDataSet = getDataSet(...);
// create random forest classifier
'''var''' forest = new RandomForest();
forest.setMaxDepth(15);
forest.setNumFeatures(2);
forest.buildClassifier(trainingDataSet);
// evaluate the model on test dataset and print summary
'''var''' eval = new Evaluation(trainingDataSet);
eval.evaluateModel(forest, testingDataSet);
System.out.println(eval.toSummaryString());

== См. также ==
* [[Виды ансамблей]]

== Источники информации ==
# [http://www.machinelearning.ru/wiki/images/3/3e/Voron-ML-Logic.pdf Логические алгоритмы классификации] {{---}} Лекция К. В. Воронцова
# [https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-5-ensembles-of-algorithms-and-random-forest-8e05246cbba7 Случайный лес] {{---}} статья на Medium, Yury Kashnitskiy
# [https://scikit-learn.org/stable/modules/tree.html Деревья решений] {{---}} scikit-learn.org
#[https://scikit-learn.org/stable/modules/ensemble.html Ансамбли классификаторов] — scikit-learn.org.

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Уменьшение размерности

2019-04-08T14:04:20Z

91.215.123.110:

Под '''уменьшением размерности''' (англ. ''dimensionality reduction'') в машинном обучении подразумевается уменьшение числа признаков набора данных. Наличие в нем признаков избыточных, неинформативных или слабо информативных может понизить эффективность модели, а после такого преобразования она упрощается, и соответственно уменьшается размер набора данных в памяти и ускоряется работа алгоритмов ML на нем. Уменьшение размерности может быть осуществлено методами выбора признаков (англ. ''feature selection'') или выделения признаков (англ. ''feature extraction'').
==Выбор признаков==
Методы '''выбора признаков''' оставляют некоторое подмножество исходного набора признаков, избавляясь от признаков избыточных и слабо информативных. Основные преимущества этого класса алгоритмов:
*Уменьшение вероятности [[переобучение|переобучения]];
*Увеличение точности предсказания модели;
*Сокращение времени обучения;
*Увеличивается семантическое понимание модели.

Все методы выбора признаков можно разделить на 5 типов, которые отличаются алгоритмами выбора лишних признаков.
===Фильтры===
'''Фильтры''' (англ. ''filter methods'') измеряют релевантность признаков на основе функции $\mu$, и затем решают по правилу $\kappa$, какие признаки оставить в результирующем множестве.

Фильтры могут быть:
*Одномерные (англ. ''univariate'') {{---}} функция $\mu$ определяет релевантность одного признака по отношению к выходным меткам. В таком случае обычно измеряют "качество" каждого признака и удаляют худшие;
*Многомерные (англ. ''multivariate'') {{---}} функция $\mu$ определяет релевантность некоторого подмножества исходного множества признаков относительно выходных меток.

Распространенными вариантами для $\mu$ являются:
*Коэффициент ранговой корреляции Спирмена <ref>[https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient Определение коэффициента ранговой корреляции Спирмена]</ref>(англ. ''Spearman's rank correlation coefficient''): $p(x, y)=\displaystyle \frac{\sum_{i, j}(x_{ij}-\bar{x_j})(y_i-\bar{y})}{\sqrt{\sum_{i, j}(x_{ij}-\bar{x_j})^2\sum_i(y_i-\bar{y})^2}}$;
*Information gain<ref>[https://en.wikipedia.org/wiki/Information_gain_in_decision_trees Определение information gain]</ref>: $IG(x, y)=\displaystyle -\sum_{i=1}^kp(c_i)\log_2{(p(c_i))}+\sum_{i=1}^{n}p(t_i)\sum_{j=1}^kp(c_j|t_i)log_2{(p(c_j|t_i))}$, и другие.

Преимуществом группы фильтров является простота вычисления релевантности признаков в наборе данных, но недостатком в таком подходе является игнорирование возможных зависимостей между признаками.
===Оберточные методы===
[[File:Feature_selection_wrapper_rus.png|450px|thumb|right|Процесс работы оберточных методов]]
'''Оберточные методы''' (англ. ''wrapper methods'') находят подмножество искомых признаков последовательно, используя некоторый классификатор как источник оценки качества выбранных признаков, т.е. этот процесс является циклическим и продолжается до тех пор, пока не будут достигнуты заданные условия останова. Оберточные методы учитывают зависимости между признаками, что является преимуществом по сравнению с фильтрами, к тому же показывают большую точность, но вычисления занимают длительное время, и повышается риск [[переобучение|переобучения]].

Существует несколько типов оберточных методов: детерминированные, которые изменяют множество признаков по определенному правилу, а также рандомизированные, которые используют генетические алгоритмы для выбора искомого подмножества признаков. Среди детерминированных алгоритмов самыми простыми являются:
*SFS (Sequential Forward Selection) {{---}} жадный алгоритм, который начинает с пустого множества признаков, на каждом шаге добавляя лучший из еще не выбранных признаков в результирующее множество;
*SBS (Sequential Backward Selection) {{---}} алгоритм обратный SFS, который начинает с изначального множества признаков, и удаляет по одному или несколько худших признаков на каждом шаге.

Популярным оберточным методом является SVM-RFE (SVM-based Recursive Feature Elimination), который иногда также обозначается как встроенный <ref>[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117/ C. Embedded method]</ref>. Этот метод использует как классификатор [[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан] и работает итеративно: начиная с полного множества признаков обучает классификатор, ранжирует признаки по весам, которые им присвоил классификатор, убирает какое-то число признаков и повторяет процесс с оставшегося подмножества фичей, если не было достигнуто их требуемое количество. Таким образом, этот метод очень похож на встроенный, потому что непосредственно использует знание того, как устроен классификатор.

===Встроенные методы===
[[File:Feature_selection_embedded_rus.png|450px|thumb|right|Процесс работы встроенных методов]]
Группа '''встроенных методов''' (англ. ''embedded methods'') очень похожа на оберточные методы, но для выбора признаков используется непосредственно структуру некоторого классификатора. В оберточных методах классификатор служит только для оценки работы на данном множестве признаков, тогда как встроенные методы используют какую-то информацию о признаках, которую классификаторы присваивают во время обучения.

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

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

===Другие методы===
[[File:Feature_selection_ensemble_rus.png|thumb|Один из примеров процесса работы ансамблевых методов]]
Есть и другие методы выбора признаков: '''гибридные''' (англ. ''hybrid methods'') и '''ансамблевые''' (англ. ''ensemble methods''). '''Гибридные методы''' комбинируют несколько разных методов выбора признаков, например, некоторое множество фильтров, а потом запускают оберточный или встроенный метод. Таким образом, гибридные методы сочетают в себе преимущества сразу нескольких методов, и на практике повышают эффективность выбора признаков.

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

<div style="clear:{{{1|both}}};"></div>

===Примеры кода scikit-learn===
Пример кода, реализующего функцию оценки фильтра на основе коэффициента ранговой корреляции:
# Импорт библиотек
import pandas as pd
import numpy as np

# Вспомогательная функция для расчета корреляции
def correlation(X, Y):
return np.cov(X, Y) / np.sqrt(np.var(X) * np.var(Y))

# Сам фильтр на основе метрики ранговой корреляции
# Аргументы X -- значения объектов датасета для какой-то фичи, Y -- метки этих объектов
def measure_spearmans(X, Y):
xr = pd.Series(X).rank()
yr = pd.Series(Y).rank()
return correlation(xr, yr)

Пример кода, реализующего SVM-RFE wrapper:
# Импорт библиотек
import numpy as np
import pandas as pd
from sklearn import svm

# X -- наш датасет, Y -- массив меток
# N -- число признаков, которые хотим оставить, step -- сколько фичей удаляется на каждой итерации
# Возвращает массив из булевых переменных размерностью 1x[число признаков], показывающий, отбрасываем признак или нет
def RFE(X, Y, N, step = 10):
# cache_size нужен, если набор данных большой, иначе можно опустить
clfRFE = svm.SVC(kernel='linear', cache_size=1024)
featureCount = X.shape[1]
featureList = np.arange(0, featureCount )
included = np.full(featureCount, True)
curCount = featureCount
while curCount > N:
actualFeatures = featureList[included]
Xnew = X[:, actualFeatures]

clfRFE.fit(Xnew, Y)
curStep = min(step, curCount - N)
elim = np.argsort(np.abs(clfRFE.coef_[0]))[:curStep]
included[actualFeatures[elim]] = False
curCount -= curStep
return included
==Выделение признаков==
Другим способом уменьшить размерность входных данных является выделение признаков. Эти методы каким-то образом составляют из уже исходных признаков новые, все также полностью описывающие пространство набора данных, но уменьшая его размерность и теряя в репрезентативности данных, т.к. становится непонятно, за что отвечают новые признаки.
Все методы feature extraction можно разделить на '''линейные''' и '''нелинейные'''.

Одним из самых известных методов '''линейного''' выделения признаков является [[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан] (Principal Component Analysis, рус. ''метод главных компонент''). Основной идеей этого метода является поиск такой гиперплоскости, на которую при ортогональной проекции всех признаков максимизируется дисперсия. Данное преобразование может быть произведено с помощью сингулярного разложения матриц и создает проекцию только на линейные многомерные плоскости, поэтому и метод находится в категории линейных.

К '''нелинейным''' методам, например, могут быть отнесены методы отображающие исходное пространство признаков на нелинейные поверхности или топологические многообразия. Одним из таких алгоритмов является [[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан] (t-distributed Stochastic Neighbor Embedding, рус. ''стохастическое вложение соседей с t-распределением''). Данный метод состоит из двух шагов: изначально строится распределение вероятностей по всем парам точек набора данных, каждая условная вероятность $p_{j|i}$ которого означает насколько точка $X_j$ близка к точке $X_i$ при гауссовом распределении вокруг $X_i$. Данное распределение как метрику похожести использует евклидово расстояние. Алгоритм старается получить отображение из точек размерности $\mathbb{R}^k$ в меньшую размерность $\mathbb{R}^d$, для этого вводится еще одно распределение, описывающее насколько точки из нового пространства похожи друг на друга, но используя при этом t-распределение Стьюдента с одной степенью свободы. Как метрику похожести двух распределений используется дивергенция Кульбака-Лейблера<ref>[https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence Дивергенция Кульбака-Лейблера]</ref>, и чтобы найти точки новой размерности $d$ запускается градиентный спуск для минимизации этой величины.
===Пример кода scikit-learn===
Пример выделения признаков с помощью PCA в scikit-learn:
# Импорт библиотек
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split

X = ... # загрузка X
Y = ... # загрузка Y
# Разделение данных на train и test
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y)

clf = ... # берем какой-то классификатор
# Обучаем PCA для выделения 5 признаков
pca = PCA(n_components=5)
pca.fit(Xtrain)
# Изменяем наши наборы данных под выбранные признаки
Xtrain = pca.transform(Xtrain)
Xtest = pca.transform(Xtest)
# Обучаем классификатор и проверяем точность его работы
clf.fit(Xtrain, Ytrain)
print ("Score: %.6f" % clf.score(Xtest, Ytest))

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример уменьшение размерности используя smile.feature.GAFeatureSelection<ref>[https://haifengl.github.io/smile/feature.html#genetic-algorithm-feature-selection Smile, Genetic Algorithm Based Feature Selection]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.feature.GAFeatureSelection
'''import '''smile.read
'''import '''smile.validation.Accuracy

// Загрузка данных
'''val '''data = read.arff("data/weka/segment-test.arff", 19)
'''val '''(x, y) = data.unzipInt
'''val '''trainer = '''new '''GradientTreeBoost.Trainer(100)
'''val '''measure = '''new '''Accuracy
// Cоздание генетического алгоритма и его настройка.
'''val '''selector = '''new '''GAFeatureSelection
// Размер популяции - 50, количество поколений - 20 
// Каждая возращаемая BitString содержит фичи и их качество.
'''val '''result = selector.learn(50, 20, trainer, measure, x, y, 5)
result.foreach { bits =>
print(100*bits.fitness)
println(bits.bits.mkString(" "))
}

===Пример на языке Java===
Пример уменьшения размерности датасета с применением <code>weka.attributeSelection.PrincipalComponents</code><ref>[http://weka.sourceforge.net/doc.dev/weka/attributeSelection/PrincipalComponents.html/ Weka, PCA]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.attributeSelection.PrincipalComponents;
'''import''' weka.core.Instances;
'''import''' weka.filters.Filter;
'''import''' weka.filters.unsupervised.attribute.NumericToNominal;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;

// load dataset
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
'''var''' filter = new NumericToNominal();
filter.setInputFormat(data);
data = Filter.useFilter(data, filter);
// initialize the PCA-based selector
'''var''' pca = new PrincipalComponents();
// dimensionality reduction is achieved through selecting enough eigenvectors to account
// for some percantege of the variance in the original data
pca.setVarianceCovered(0.95);
pca.buildEvaluator(data);
// transform the dataset
data = pca.transformedData(data);

==См. также==
*[[Переобучение]]
*[[Метод опорных векторов (SVM)| SVM]][на 28.01.19 не создан]
*[[Дерево решений и случайный лес| Случайный лес]]
*[[Метод главных компонент (PCA)| PCA]][на 28.01.19 не создан]
*[[Стохастическое вложение соседей с t-распределением |t-SNE]][на 28.01.19 не создан]
==Примечания==
<references/>
==Источники информации==
#[http://research.cs.tamu.edu/prism/lectures/pr/pr_l11.pdf Sequential feature selection] {{---}} курс ML Texas A&M University
#[https://en.wikipedia.org/wiki/Feature_selection Feature selection] {{---}} статья про Feature Selection в Wikipedia
#[https://benthamopen.com/FULLTEXT/TOBIOIJ-11-117 Публикация про feature selection]
#[https://towardsdatascience.com/feature-selection-using-random-forest-26d7b747597f Embedded random forest]

[[Категория: Машинное обучение]]
[[Категория: Уменьшение размерности]]

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

2019-04-08T14:03:56Z

91.215.123.110:

'''Метрический классификатор''' (англ. similarity-based classifier) {{---}} алгоритм классификации, основанный на вычислении оценок сходства между объектами.

Для формализации понятия сходства вводится функция расстояния между объектами <tex>\rho(x,x')</tex>. Как правило, не требуется, чтобы были выполнены все три аксиомы метрики {{---}} неравенство треугольника может нарушаться.

'''Метод ближайших соседей''' {{---}} простейший метрический классификатор, основанный на оценивании сходства объектов. Классифицируемый объект относится к тому классу, которому принадлежат ближайшие к нему объекты обучающей выборки.

'''Метод <tex>k</tex> ближайших соседей''' (англ. kNN {{---}} <tex>k</tex> Nearest Neighbours) {{---}} Для повышения надёжности классификации объект относится к тому классу, которому принадлежит большинство из его соседей {{---}} <tex>k</tex> ближайших к нему объектов обучающей выборки <tex>x_i</tex>. В задачах с двумя классами число соседей берут нечётным, чтобы не возникало ситуаций неоднозначности, когда одинаковое число соседей принадлежат разным классам.

'''Метод взвешенных ближайших соседей''' {{---}} в задачах с числом классов 3 и более нечётность уже не помогает и ситуации неоднозначности всё равно могут возникать. Тогда <tex>i</tex>-му соседу приписывается вес <tex>w_i</tex>, как правило, убывающий с ростом ранга соседа <tex>i</tex>. Объект относится к тому классу, который набирает больший суммарный вес среди <tex>k</tex> ближайших соседей.

== Описание алгоритма ==
Пусть задана обучающая выборка пар "объект-ответ" <tex>X^m = \{(x_1,y_1),\dots,(x_m,y_m)\}.</tex>

Пусть на множестве объектов задана функция расстояния <tex>\rho(x,x')</tex>. Эта функция должна быть достаточно адекватной моделью сходства объектов. Чем больше значение этой функции, тем менее схожими являются два объекта <tex>x, x'</tex>.

Для произвольного объекта <tex>u</tex> расположим объекты обучающей выборки <tex>x_i</tex> в порядке возрастания расстояний до <tex>u</tex>:

<tex>\rho(u,x_{1; u}) \leq \rho(u,x_{2; u}) \leq \cdots \leq \rho(u,x_{m; u})</tex>,
где через <tex>x_{i; u}</tex> обозначается тот объект обучающей выборки, который является <tex>i</tex>-м соседом объекта <tex>u</tex>. Аналогичное обозначение введём и для ответа на <tex>i</tex>-м соседе: <tex>y_{i; u}</tex>. Таким образом, произвольный объект <tex>u</tex> порождает свою перенумерацию выборки. В наиболее общем виде алгоритм ближайших соседей есть:
<tex>a(u) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] w(i,u)</tex>,

где <tex>w(i,u)</tex> {{---}} заданная весовая функция, которая оценивает степень важности <tex>i</tex>-го соседа для классификации объекта <tex>u</tex>. Естественно полагать, что эта функция не отрицательна и не возрастает по <tex>i</tex> (поскольку чем дальше объект, тем меньший вклад он должен вносить в пользу своего класса).

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

<tex>w(i,u) = [i=1]</tex> {{---}} простейший метод ближайшего соседа;

<tex>w(i,u) = [i\leq k]</tex> {{---}} метод <tex>k</tex> ближайших соседей;

<tex>w(i,u) = [i\leq k] q^i</tex> {{---}} метод <tex>k</tex> экспоненциально взвешенных ближайших соседей, где предполагается константа <tex>q < 1</tex>;

[[Файл:SimpleKnnExample.png|frame|none|super|upright=1|Пример классификации, методом 5 ближайших соседей]]

== Использование ядер сглаживания ==
При использовании линейной функции в качестве <tex>w(i, u)</tex> возможно совпадение суммарного веса для нескольких классов. Это приводит к неоднозначности ответа при классификации. Чтобы такого не происходило, используют функцию [[Ядра]][на 28.01.18 не создан].

Будем обозначать функцию ядра <tex>K(r)</tex>.

=== Примеры ядер ===

Triangular: <tex>{\displaystyle K(r)=(1-|r|)}</tex>,

Parabolic: <tex>{\displaystyle K(r)={\frac {3}{4}}(1-r^{2})}</tex>,

Tricube: <tex>{\displaystyle K(r)={\frac {70}{81}}(1-{\left|r\right|}^{3})^{3}}</tex>.

=== Метод парзеновского окна ===

Алгоритм <tex>k</tex> ближайших соседей можно обобщить с помощью функции ядра. Рассмотрим два способа, которыми это можно сделать.

<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex> {{---}} метод парзеновского окна фиксированной ширины <tex>h</tex>;

<tex>w(i,u) = K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex> {{---}} метод парзеновского окна переменной ширины;

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

Фиксированной ширины: <tex>a_h = a(u, X^m, \boldsymbol{h}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{h}\biggr)</tex>,

Переменной ширины: <tex>a_k = a(u, X^m, \boldsymbol{k}, K) = \mathrm{arg}\max_{y\in Y} \sum_{i=1}^m \bigl[ y_{i; u}=y \bigr] K\biggl(\frac{\rho(u,x_{i; u})}{\rho(u,x_{k+1; u})}\biggr)</tex>.

<tex>a_h</tex> не будет учитывать соседей на расстояние больше чем <tex>h</tex>, а всех остальных учтет в соответствии с функций ядра <tex>K</tex>.
<tex>a_k</tex> является аналогом метода <tex>k</tex> ближайших соседей (т.к. для всех <tex>k+i</tex>-ых соседей функция <tex>K</tex> вернет 0), но при этом чем ближе <tex>k-i</tex>-ый сосед, тем больший вклад в сторону своего класса он даст.

Часто используют окно переменной ширины т.е. классификатор <tex>a_k</tex>, по следующим причинам:

# Удобнее оптимизировать целочисленный параметр <tex>k</tex>, чем вещественный параметр <tex>h</tex> по некоторой сетке;

# Существует большое количество задач, где точки разбросаны неравномерно. В них могут существовать области, где достаточно брать небольшую <tex>h</tex> и области, где в окно ширины <tex>h</tex> попадает только одна точка. Тогда для классификатора <tex>a_h</tex> будут существовать области в которых не будет ни одного объекта (кроме того, который нужно классифицировать). Для таких областей не понятно как классифицировать объекты.

[[Файл:KnnExample.png|frame|none|super|upright=1|Пример классификации, методом с постоянной шириной окна, и неравномерным разбросом точек]]

== Использование различных метрик расстояния ==
Очень редко известна хорошая функция расстояния <tex>\rho(x,x')</tex>. В качестве нее обычно использую следующие функции:

=== Примеры метрик ===
Пусть <tex>x</tex>, <tex>y</tex> {{---}} объекты, а <tex>(x_1, x_2,..., x_n)</tex>, <tex>(y_1, y_2,..., y_n)</tex> их признаковые описания.

Евклидова метрика: <tex>\rho(x,y) = \sqrt {\sum _{i=1}^{n}(x_{i}-y_{i})^{2}}</tex>,

Расстояние Чебышёва: <tex>\rho(x,y)=\max _{i=1,\dots ,n}|x_{i}-y_{i}|</tex>,

Манхэттенское Расстояние: <tex>\rho(x,y)=\sum _{i=1}^{n}|x_{i}-y_{i}|</tex>.

При их использовании важно нормировать значения признаков, иначе один признак с максимальным значением может стать преобладающим, а признаки с маленькими значениями не будут учитываться при классификации. Чтобы отсеять лишние признаки (т.е. не влияющие на класс объекта) можно использовать [http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8 feature selection].

== Пример использования (через scikit-learn) ==

Рассмотрим использование алгоритма <tex>kNN</tex> на примере [https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29 реального набора данных].
Предположим, что мы загрузили <tex>wdbc.data</tex> и сохранили как <tex>tr.csv</tex> с заголовком {{---}} описанием признаков.

* Загружаем данные

'''import''' pandas '''as''' pd
'''from''' sklearn.preprocessing '''import''' StandardScaler

'''def''' load_data(data_path):
ds = pd.read_csv(data_path, names=["id", "diagnosis", "radius_mean", "texture_mean", "perimeter_mean", "area_mean",
"smoothness_mean", "compactness_mean", "concavity_mean", "concave points_mean",
"symmetry_mean", "fractal_dimension_mean", "radius_se", "texture_se",
"perimeter_se", "area_se", "smoothness_se", "compactness_se", "concavity_se",
"concave points_se", "symmetry_se", "fractal_dimension_se", "radius_worst",
"texture_worst", "perimeter_worst", "area_worst", "smoothness_worst",
"compactness_worst", "concavity_worst", "concave points_worst", "symmetry_worst",
"fractal_dimension_worst"])
y = ds['diagnosis']
X = ds.drop('diagnosis', axis=1)
X = X.drop('id', axis=1)
i = len(X.columns)
X = X.drop(X.columns[i - 1], axis=1)
y.replace(('M', 'B'), (1, 0), inplace=True)
sc = StandardScaler()
sc.fit(X)
X_ans = sc.transform(X)
return X_ans, y

X, y = load_data("tr.csv")

Теперь <tex>X</tex>, <tex>y</tex> {{---}} нормированные значения признаков и соответствующие им классы.

* Делим данные на тренировочное и тестовое множество:
'''from''' sklearn.model_selection '''import''' train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1234)

* Создаем классификатор:
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier

best_model = KNeighborsClassifier(
'''n_neighbors'''=10,
'''weights'''=’distance’,
'''algorithm'''=’auto’,
'''leaf_size'''=30,
'''metric'''=’euclidean’,
'''metric_params'''=None,
'''n_jobs'''=4
)

* Обучаемся:

best_model.fit(X_train, y_train)

* Используем скользящий контроль для поиска лучших параметров (англ. cross validation):
'''from''' sklearn.model_selection '''import''' GridSearchCV

model_params = best_model.get_params()
tuned_params = {}
for k, v in model_params.items():
tuned_params[k] = [v]
tuned_params['n_neighbors'] = range(1, 30)
clf = GridSearchCV(KNeighborsClassifier(), tuned_params, cv=10, n_jobs=-1)
clf.fit(X_train, y_train)
best_params = clf.best_params_

* Оценка классификатора:
'''from''' sklearn '''import''' metrics

best_model = KNeighborsClassifier(**best_params)
best_model.fit(X_train, y_train)
predicted = best_model.predict(X_test)

* Выводим результат:
print('Used params:', best_params)
print('Evaluation:\n', metrics.classification_report(y_test, predicted))

> '''Used params''': {'metric_params': None, 'metric': 'euclidean', 'weights': 'distance', 'n_neighbors': 9, 'leaf_size': 30, 'n_jobs': 4, 'p': 2, 'algorithm': 'auto'}
'''Evaluation:'''
precision recall f1-score support
0 0.90 1.00 0.95 69
1 1.00 0.82 0.90 45
micro avg 0.93 0.93 0.93 114
macro avg 0.95 0.91 0.92 114
weighted avg 0.94 0.93 0.93 114

==Пример на языке Scala==
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.knn<ref>[https://haifengl.github.io/smile/classification.html#knn Smile, KNN]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''toy: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = toy.x()
'''val '''y: Array['''Int'''] = toy.y().map(_.toInt)
'''val '''KNN: KNN[Array['''Double''']] = knn(x, y, 3)
'''val '''predictions: Array['''Int'''] = x.map(KNN.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, KNN)

==Пример на языке Java==
Пример классификации датасета с применением <code>weka.classifiers.lazy.IBk</code><ref>[http://weka.sourceforge.net/doc.stable-3-8/weka/classifiers/lazy/IBk.html/ Weka, KNN]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.Evaluation;
'''import''' weka.classifiers.lazy.IBk;
'''import''' weka.core.converters.ConverterUtils;

// read dataset and build knn-classifier
'''var''' source = new ConverterUtils.DataSource("iris.csv");
'''var''' dataset = source.getDataSet();
'''var''' ibk = new IBk();
ibk.buildClassifier(dataset);
// test the model
'''var''' eTest = new Evaluation(dataset);
eTest.evaluateModel(ibk, dataset);
// print results summary
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

== См. также ==
* [[Обзор библиотек для машинного обучения на Python]]
* [[Общие понятия]]
* [[Уменьшение размерности]]

== Примечания ==
<references/>

== Источники информации ==
* [http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 machinelearning.ru {{---}} Метрический классификатор]
* [http://www.machinelearning.ru/wiki/index.php?title=KNN machinelearning.ru {{---}} Метод ближайших соседей (kNN)]
* [https://www.youtube.com/watch?v=l1xGQMowWA4&t=0s&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=3 Лекция "Метрические методы классификации" К.В. Воронцов, курс "Машинное обучение" 2014]
* [https://en.wikipedia.org/wiki/Kernel_(statistics) Wikipedia {{---}} Kernel (statistics)]
* [https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html Документация по scikit-learn]
* [https://www.kaggle.com/jeffbrown/knn-classifier/data Пример по работе с датасетом с kaggle]

[[Категория: Машинное обучение]]
[[Категория: Метрический классификатор]]

Байесовская классификация

2019-04-08T14:03:08Z

91.215.123.110:

== Вероятностная постановка задачи классификации ==

Пусть $X$ множество объектов, $Y$ конечное множество имён классов,
множество $X \times Y$ является вероятностным пространством с плотностью распределения $p(x,y)=P(y)p(x|y)$.
Вероятности появления объектов каждого из классов $P_y=P(y)$ называются ''априорными вероятностями классов''.
Плотности распределения $p_y(x)=p(x|y)$ называются ''функциями правдоподобия классов''.

'''Вероятностная постановка задачи классификации разделяется на две независимые подзадачи:'''
* Имеется простая выборка $X^l=(x_i, y_i)^l_{i=1}$ из неизвестного распределения $p(x,y)=P_yp_y(x)$. Требуется построить ''эмпирические оценки'' априорных вероятностей $P'_y$ и функций правдоподобия $p'_y(x)$ для каждого из классов $y \in Y$.
* По известным плотностям распределения $p_y(x)$ и априорным вероятностям $P_y$ всех классов $y \in Y$ построить алгоритм $a(x)$, минимизирующий вероятность ошибочной классификации.

Априорные вероятности классов $P_y$ можно оценить согласно закону больших чисел,
тогда частота появления объектов каждого из классов равна $P'_y=\frac{l_y}{l}$ где $l_y=|X^l_y|, y \in Y$
сходится по вероятности к $P_y$ при $l_y \to \infty$. Чем больше длина выборки, тем точнее выборочная оценка $P'_y$.

== Оптимальный байесовский классификатор ==

Рассмотрим произвольный алгоритм $a:X \to Y$.
Он разбивает множество $X$ на не пересекающиеся области $A_y=\{x \in X | a(x) = y\}, y \in Y$.
Вероятность того,что появится объект класса $y$ и алгоритм $a$ отнесёт его к классу $s$, равна $P_yP(A_s|y)$.
Каждой паре $(y,s) \in Y \times Y$ поставим в соответствие величину потери $\lambda_{ys}$
при отнесении объекта класса $y$ к классу $s$.

{{Определение
|definition =
'''Функционал среднего риска''' {{---}} ожидаемая величина потери при классификации объектов алгоритмом $a$:
:<tex> R(a) = \displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) </tex>
}}

{{Теорема
|about=
об оптимальности байесовского классификатора
|statement=
Если известны априорные вероятности $P_y$ и функции правдоподобия $p_y(x)$,
то минимум среднего риска $R(a)$ достигается алгоритмом
:<tex> a(x) = \displaystyle\arg\min_{s \in Y}\sum_{y \in Y}\lambda_{ys}P_yp_y(x) </tex>
|proof=

Для произвольного $t \in Y$ запишем функционал среднего риска:

:<tex> R(a)=\displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) = \sum_{y \in Y}\lambda_{yt}P_yP(A_t|y) + \sum_{s \in Y\setminus\{t\} }\sum_{y \in Y}\lambda_{ys}P_yP(A_s|y).</tex>

Применив формулу полной вероятности, $P(A_t \mid y) = 1 −\displaystyle\sum_{ s \in Y \setminus \{t\} }P(A_s \mid y)$, получим:

:<tex> R(a) = \displaystyle\sum_{y \in Y}\lambda_{yt}P_y + \sum_{ s \in Y \setminus \{t\} } \sum_{y \in Y} (\lambda_{ys} - \lambda_{yt})P_yP(A_s|y) = </tex>

:<tex> = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} } \int_{A_s}\sum_{y \in Y} (\lambda_{ys}−\lambda_{yt})P_yp_y(x)dx. </tex>

Введём для сокращения записи обозначение
$g_s(x) = \displaystyle\sum_{y \in Y}\lambda_{ys}P_yp_y(x)$, тогда
$R(a) = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} }\int_{A_s}(g_s(x)−g_t(x))dx$.

Минимум интегрла достигается, когда $A_s$ совпадает с областью неположительности подынтегрального выражения.
:<tex> A_s=\{x \in X \mid g_s(x) \leq g_t(x), \forall t \in Y, t \leq s\}. </tex>

С другой стороны, $A_s=\{x \in X \mid a(x) = s\}$. Значит, $a(x) = s$ тогда и только тогда, когда
:$s= \displaystyle\arg\min_{t \in Y}g_t(x)$.
}}

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

Допустим, что объекты $x \in X$ описываются $n$ числовыми признаками $f_j:X→R,j= 1,...,n$.
Обозначим через $x = (\xi_1,...,\xi_n)$ произвольный элемент пространства объектов $X=R^n$, где $\xi_j=f_j(x)$.

Предположим, что признаки $f_1(x),...,f_n(x)$ являются независимыми случайными величинами.
Следовательно, функции правдоподобия классов представимы в виде:

:<tex> p_y(x) = \displaystyle\prod^n_{i=1}p_{yi}(\xi_i) </tex>

где $p_{yj}(\xi_j)$ плотность распределения значений $j$-го признака для класса $y$.
Алгоритмы классификации исходящие из этого предположения, называются ''наивными байесовскими''.

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

:<tex> a(x) = \displaystyle\arg\max_{y \in Y}(\ln\lambda_yP'_y + \sum^n_{j=1}\ln p'_{yj}(\xi_j)). </tex>

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

Основной его недостаток {{---}} низкое качество классификации в общем случае.

== Применение ==

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

Рассмотрим частое применение байесовского классификатора к задаче классификации документов по их содержимому,
а именно к классификации электронных писем на два класса {{---}} спам ($S$) и не-спам ($\displaystyle \neg S$),
предполагая что вероятность слов в тексте не зависит друг от друга:

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

:<tex> P(a\ very\ close\ game) = P(a) \times P(very) \times P(close) \times P(game) </tex>

Исходя из такого предположения, для решения задачи классификации сообщений лишь на 2 класса:
$S$ (спам) и $H = \neg S$ («хэм», то есть не спам) из теоремы Байеса можно вывести следующую формулу оценки вероятности «спамовости» всего сообщения $D$,
содержащего слова $W_1, W_2, ... W_N$:

:<tex>\displaystyle p(S\mid D) = p(S\mid W_1, W_2, ... W_N) = \frac{p(W_1, W_2, ... W_N\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = </tex> [так как $W_i$ предполагаются независимыми] <tex>=</tex>

:<tex>= \displaystyle\frac{\prod_{i} p(W_i\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = \frac{\prod_{i}p(S\mid W_i)}{\prod_i(p(S\mid W_i)) + \left(\frac{p(\neg S)}{p(S)}\right)^{1-N} \cdot \prod_i p(\neg S\mid W_i)} </tex>

Результат $p$ обычно сравнивают с некоторым порогом (например, $0.5$), чтобы решить, является ли сообщение спамом или нет. Если $p$ ниже, чем порог, сообщение рассматривают как вероятный «ham», иначе его рассматривают как вероятный спам.

:<tex>\displaystyle\ln{p(S\mid D)\over p(\neg S\mid D)} > h</tex>.

==Примеры кода==
===Пример кода scikit-learn===

Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB GaussianNB] реализует наивный байесовский классификатор в предположении что изначальное распределение было гауссовым:

:<tex> P(x_i \mid y) = \displaystyle\frac{1}{\sqrt{2\pi\sigma^2_y}}\exp(-\frac{(x_i - \mu_y)^2}{2\sigma^2_y}) </tex>

'''from''' sklearn '''import''' datasets
'''from''' sklearn.metrics '''import''' f1_score, accuracy_score
'''from''' sklearn.naive_bayes '''import''' GaussianNB
iris = datasets.load_iris()
gnb = GaussianNB()
pred = gnb.fit(iris.data, iris.target).predict(iris.data)
accuracy = accuracy_score(iris.target, pred)
f1 = f1_score(iris.target, pred, average="micro")
'''print'''(''"accruracy:"'', accuracy, ''"f1:"'', f1)

Вывод:
accruracy: 0.96 f1: 0.96

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.bayes.NaiveBayes</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/bayes/NaiveBayes.html/ Weka, Naive Bayes]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.bayes.NaiveBayes;
'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.core.converters.ConverterUtils;
'''import''' java.util.Random;

// load dataset
'''var''' source = new DataSource("/iris.arff");
'''var''' dataset = source.getDataSet();
//set class index to the last attribute
dataset.setClassIndex(dataset.numAttributes() - 1);
//create and build the classifier
'''var''' nb = new NaiveBayes();
nb.buildClassifier(dataset);
// cross validate model
var eval = new Evaluation(dataset);
eval.crossValidateModel(nb, dataset, 10, new Random(41));
System.out.println("Estimated Accuracy: "+ Double.toString(eval.pctCorrect()));

==См. также==
*[[:Байесовские сети|Байесовские сети]]
*[[:Независимые события|Независимые события]]
*[[:Формула Байеса|Формула Байеса]]

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 Википедия {{---}} Наивный байесовский классификатор]
* [http://www.machinelearning.ru/wiki/images/6/6d/Voron-ML-1.pdf К.В.Воронцов Математические методы обучения по прецедентам]
* [https://scikit-learn.org/stable/modules/naive_bayes.html Scikit-learn 1.9. Supervised learning - Naive Bayes]

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Байесовская классификация

2019-04-08T14:01:38Z

91.215.123.110:

== Вероятностная постановка задачи классификации ==

Пусть $X$ множество объектов, $Y$ конечное множество имён классов,
множество $X \times Y$ является вероятностным пространством с плотностью распределения $p(x,y)=P(y)p(x|y)$.
Вероятности появления объектов каждого из классов $P_y=P(y)$ называются ''априорными вероятностями классов''.
Плотности распределения $p_y(x)=p(x|y)$ называются ''функциями правдоподобия классов''.

'''Вероятностная постановка задачи классификации разделяется на две независимые подзадачи:'''
* Имеется простая выборка $X^l=(x_i, y_i)^l_{i=1}$ из неизвестного распределения $p(x,y)=P_yp_y(x)$. Требуется построить ''эмпирические оценки'' априорных вероятностей $P'_y$ и функций правдоподобия $p'_y(x)$ для каждого из классов $y \in Y$.
* По известным плотностям распределения $p_y(x)$ и априорным вероятностям $P_y$ всех классов $y \in Y$ построить алгоритм $a(x)$, минимизирующий вероятность ошибочной классификации.

Априорные вероятности классов $P_y$ можно оценить согласно закону больших чисел,
тогда частота появления объектов каждого из классов равна $P'_y=\frac{l_y}{l}$ где $l_y=|X^l_y|, y \in Y$
сходится по вероятности к $P_y$ при $l_y \to \infty$. Чем больше длина выборки, тем точнее выборочная оценка $P'_y$.

== Оптимальный байесовский классификатор ==

Рассмотрим произвольный алгоритм $a:X \to Y$.
Он разбивает множество $X$ на не пересекающиеся области $A_y=\{x \in X | a(x) = y\}, y \in Y$.
Вероятность того,что появится объект класса $y$ и алгоритм $a$ отнесёт его к классу $s$, равна $P_yP(A_s|y)$.
Каждой паре $(y,s) \in Y \times Y$ поставим в соответствие величину потери $\lambda_{ys}$
при отнесении объекта класса $y$ к классу $s$.

{{Определение
|definition =
'''Функционал среднего риска''' {{---}} ожидаемая величина потери при классификации объектов алгоритмом $a$:
:<tex> R(a) = \displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) </tex>
}}

{{Теорема
|about=
об оптимальности байесовского классификатора
|statement=
Если известны априорные вероятности $P_y$ и функции правдоподобия $p_y(x)$,
то минимум среднего риска $R(a)$ достигается алгоритмом
:<tex> a(x) = \displaystyle\arg\min_{s \in Y}\sum_{y \in Y}\lambda_{ys}P_yp_y(x) </tex>
|proof=

Для произвольного $t \in Y$ запишем функционал среднего риска:

:<tex> R(a)=\displaystyle\sum_{y \in Y}\sum_{s \in Y}\lambda_{ys}P_yP(A_s|y) = \sum_{y \in Y}\lambda_{yt}P_yP(A_t|y) + \sum_{s \in Y\setminus\{t\} }\sum_{y \in Y}\lambda_{ys}P_yP(A_s|y).</tex>

Применив формулу полной вероятности, $P(A_t \mid y) = 1 −\displaystyle\sum_{ s \in Y \setminus \{t\} }P(A_s \mid y)$, получим:

:<tex> R(a) = \displaystyle\sum_{y \in Y}\lambda_{yt}P_y + \sum_{ s \in Y \setminus \{t\} } \sum_{y \in Y} (\lambda_{ys} - \lambda_{yt})P_yP(A_s|y) = </tex>

:<tex> = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} } \int_{A_s}\sum_{y \in Y} (\lambda_{ys}−\lambda_{yt})P_yp_y(x)dx. </tex>

Введём для сокращения записи обозначение
$g_s(x) = \displaystyle\sum_{y \in Y}\lambda_{ys}P_yp_y(x)$, тогда
$R(a) = const(a) + \displaystyle\sum_{ s \in Y \setminus \{t\} }\int_{A_s}(g_s(x)−g_t(x))dx$.

Минимум интегрла достигается, когда $A_s$ совпадает с областью неположительности подынтегрального выражения.
:<tex> A_s=\{x \in X \mid g_s(x) \leq g_t(x), \forall t \in Y, t \leq s\}. </tex>

С другой стороны, $A_s=\{x \in X \mid a(x) = s\}$. Значит, $a(x) = s$ тогда и только тогда, когда
:$s= \displaystyle\arg\min_{t \in Y}g_t(x)$.
}}

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

Допустим, что объекты $x \in X$ описываются $n$ числовыми признаками $f_j:X→R,j= 1,...,n$.
Обозначим через $x = (\xi_1,...,\xi_n)$ произвольный элемент пространства объектов $X=R^n$, где $\xi_j=f_j(x)$.

Предположим, что признаки $f_1(x),...,f_n(x)$ являются независимыми случайными величинами.
Следовательно, функции правдоподобия классов представимы в виде:

:<tex> p_y(x) = \displaystyle\prod^n_{i=1}p_{yi}(\xi_i) </tex>

где $p_{yj}(\xi_j)$ плотность распределения значений $j$-го признака для класса $y$.
Алгоритмы классификации исходящие из этого предположения, называются ''наивными байесовскими''.

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

:<tex> a(x) = \displaystyle\arg\max_{y \in Y}(\ln\lambda_yP'_y + \sum^n_{j=1}\ln p'_{yj}(\xi_j)). </tex>

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

Основной его недостаток {{---}} низкое качество классификации в общем случае.

== Применение ==

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

Рассмотрим частое применение байесовского классификатора к задаче классификации документов по их содержимому,
а именно к классификации электронных писем на два класса {{---}} спам ($S$) и не-спам ($\displaystyle \neg S$),
предполагая что вероятность слов в тексте не зависит друг от друга:

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

:<tex> P(a\ very\ close\ game) = P(a) \times P(very) \times P(close) \times P(game) </tex>

Исходя из такого предположения, для решения задачи классификации сообщений лишь на 2 класса:
$S$ (спам) и $H = \neg S$ («хэм», то есть не спам) из теоремы Байеса можно вывести следующую формулу оценки вероятности «спамовости» всего сообщения $D$,
содержащего слова $W_1, W_2, ... W_N$:

:<tex>\displaystyle p(S\mid D) = p(S\mid W_1, W_2, ... W_N) = \frac{p(W_1, W_2, ... W_N\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = </tex> [так как $W_i$ предполагаются независимыми] <tex>=</tex>

:<tex>= \displaystyle\frac{\prod_{i} p(W_i\mid S) \cdot p(S)}{p(W_1, W_2, ... W_N)} = \frac{\prod_{i}p(S\mid W_i)}{\prod_i(p(S\mid W_i)) + \left(\frac{p(\neg S)}{p(S)}\right)^{1-N} \cdot \prod_i p(\neg S\mid W_i)} </tex>

Результат $p$ обычно сравнивают с некоторым порогом (например, $0.5$), чтобы решить, является ли сообщение спамом или нет. Если $p$ ниже, чем порог, сообщение рассматривают как вероятный «ham», иначе его рассматривают как вероятный спам.

:<tex>\displaystyle\ln{p(S\mid D)\over p(\neg S\mid D)} > h</tex>.

==Примеры кода==
===Пример кода scikit-learn===

Классификатор [https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB GaussianNB] реализует наивный байесовский классификатор в предположении что изначальное распределение было гауссовым:

:<tex> P(x_i \mid y) = \displaystyle\frac{1}{\sqrt{2\pi\sigma^2_y}}\exp(-\frac{(x_i - \mu_y)^2}{2\sigma^2_y}) </tex>

'''from''' sklearn '''import''' datasets
'''from''' sklearn.metrics '''import''' f1_score, accuracy_score
'''from''' sklearn.naive_bayes '''import''' GaussianNB
iris = datasets.load_iris()
gnb = GaussianNB()
pred = gnb.fit(iris.data, iris.target).predict(iris.data)
accuracy = accuracy_score(iris.target, pred)
f1 = f1_score(iris.target, pred, average="micro")
'''print'''(''"accruracy:"'', accuracy, ''"f1:"'', f1)

Вывод:
accruracy: 0.96 f1: 0.96

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.bayes.NaiveBayes</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/bayes/NaiveBayes.html/ Weka, Naive Bayes]</ref>

<code>Maven</code> зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

// load dataset
'''var''' source = new DataSource("/iris.arff");
'''var''' dataset = source.getDataSet();
//set class index to the last attribute
dataset.setClassIndex(dataset.numAttributes() - 1);
//create and build the classifier
'''var''' nb = new NaiveBayes();
nb.buildClassifier(dataset);
// cross validate model
var eval = new Evaluation(dataset);
eval.crossValidateModel(nb, dataset, 10, new Random(41));
System.out.println("Estimated Accuracy: "+ Double.toString(eval.pctCorrect()));

==См. также==
*[[:Байесовские сети|Байесовские сети]]
*[[:Независимые события|Независимые события]]
*[[:Формула Байеса|Формула Байеса]]

== Источники информации ==

* [https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D0%B9%D0%B5%D1%81%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80 Википедия {{---}} Наивный байесовский классификатор]
* [http://www.machinelearning.ru/wiki/images/6/6d/Voron-ML-1.pdf К.В.Воронцов Математические методы обучения по прецедентам]
* [https://scikit-learn.org/stable/modules/naive_bayes.html Scikit-learn 1.9. Supervised learning - Naive Bayes]

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]

Примеры кода на Java

2019-04-08T13:56:47Z

91.215.123.110:

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных) нейронных сетей.
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price);
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);
===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)}}
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Примеры кода на Java

2019-04-08T13:50:31Z

91.215.123.110: Новая страница: «Java: https://www.oracle.com/java/ ==Популярные библиотеки== * <code>Weka</code><ref>[https://www.cs.waikato.ac.…»

[[File:Java.jpeg|auto|thumb|Java: https://www.oracle.com/java/]]
==Популярные библиотеки==
* <code>Weka</code><ref>[https://www.cs.waikato.ac.nz/~ml/weka/ Weka]</ref> {{---}} популярная библиотека, написанная на языке <code>Java</code> и содержащая в себе множество алгоритмов машинного обучения для задач анализа данных. Предоставляет инструменты для решения задач классификации, кластеризации данных, регрессионного анализа и др.
* <code>Smile</code><ref>[https://haifengl.github.io/smile/ Smile, Statistical Machine Intelligence and Learning Engine]</ref> {{---}} <code>Java</code> фреймворк для машинного обучения, анализа естественного языка, линейной алгебры и визуализации данных. <code>Smile</code> покрывает все основные аспекты машинного обучения и предоставляет высокопроизводительные алгоритмы и структуры данных.
* <code>deeplearning4j</code><ref>[https://github.com/deeplearning4j/deeplearning4j deeplearning4j, deep learning & linear algebra for Java/Scala with GPUs + Spark]</ref> {{---}} <code>Java</code> библиотека для глубокого обучения, создания рекуррентых (в том числе распределенных нейронных сетей).
==Примеры кода==
Для работы с приведенными ниже примерами необходим <code>JDK</code> версии не ниже 10 и система сборки <code>Maven</code>. 
Каждый пример структурирован следующим образом:
# <code>Maven</code> зависимость на необходимые библиотеки
# Список необходимых <code>import</code> директив
# Код примера с комментариями
===Вариации регрессии===
{{main|Вариации регрессии}}
====Линейная регрессия====
{{main|Линейная регрессия}}
Пример линейной регресии с применением <code>weka.classifiers.functions.LinearRegression</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/LinearRegression.html/ Weka, Linear Regression]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.LinearRegression;
'''import''' weka.core.Instance;
'''import''' weka.core.Instances;

//Load Data set
'''var''' data = new Instances(new BufferedReader(new FileReader("dataset/house.arff")));
data.setClassIndex(data.numAttributes() - 1);
//Build model
'''var''' model = new LinearRegression();
'''try''' { model.buildClassifier(data); }
'''catch''' (Exception e) { e.printStackTrace(); }
//output model
System.out.printf("model parameters: %s%n", model);
// Now Predicting the cost
'''var''' myHouse = data.lastInstance();
'''var''' price = model.classifyInstance(myHouse);
System.out.printf("predicted price = %s%n", price);
====Логистическая регрессиия====
{{main|Логистическая регрессия}}
Пример линейной регрессии с применением <code>smile.classification.LogisticRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/LogisticRegression/ Smile, Logistic Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.AttributeDataset;
'''import''' smile.data.NominalAttribute;
'''import''' smile.classification.LogisticRegression;
'''import''' smile.data.parser.ArffParser;

'''var''' arffParser = new ArffParser();
arffParser.setResponseIndex(4);
'''var''' iris = arffParser.parse(smile.data.parser.IOUtils.getTestDataFile("weka/iris.arff"));
'''var''' logClf = new LogisticRegression(iris.x(), iris.labels());
logClf.predict(testX);
====Гребневая регрессия (ридж-регрессия)====
{{Main|Вариации регрессии#Гребневая регрессия (ридж-регрессия)}}

Пример гребневой регрессии с применением <code>smile.regression.RidgeRegression</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/RidgeRegression.html/ Smile, Ridge Regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.RidgeRegression;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lambda = 0.0057d;
'''var''' ridgeClf = new RidgeRegression(dataset.x(), dataset.y(), lambda);
ridgeClf.predict(testX);
====Лассо-регрессия====
{{Main|Вариации регрессии#Лассо-регрессия}}

Пример Лассо-регрессии с применением <code>smile.regression.LASSO</code><ref>[https://haifengl.github.io/smile/api/java/smile/regression/LASSO.html/ Smile, LASSO regression]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.regression.LASSO;

'''var''' parser = new DelimitedTextParser();
parser.setDelimiter(", ");
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' dataset = parser.parse("dataset.csv");
'''var''' lasso = new LASSO(dataset.x(), dataset.y(), 10);
lasso.predict(testX);
===Классификация при помощи MLP===
{{main|Нейронные сети, перцептрон}}
Пример классификации с применением <code>weka.classifiers.functions.MultilayerPerceptron</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/functions/MultilayerPerceptron.html/ Weka, MLP]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.functions.MultilayerPerceptron;
'''import''' weka.core.converters.CSVLoader;
'''import''' java.io.File;

'''var''' trainds = new DataSource("etc/train.csv");
'''var''' train = trainds.getDataSet();
train.setClassIndex(train.numAttributes() - 1);
'''var''' testds = new DataSource("etc/test.csv");
'''var''' test = testds.getDataSet();
test.setClassIndex(test.numAttributes() - 1);
'''var''' mlp = new MultilayerPerceptron();
mlp.buildClassifier(train);
// Test the model
'''var''' eTest = new Evaluation(train);
eTest.evaluateModel(mlp, test);
// Print the result à la Weka explorer:
'''var''' strSummary = eTest.toSummaryString();
System.out.println(strSummary);

===Рекуррентные нейронные сети===
{{Main|Рекуррентные нейронные сети}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/basic/BasicRNNExample.java Пример] простой рекуррентной нейронной сети, способной генерировать заданную строку по первому символу, с применением библиотеки <code>deeplearning4j</code>.
===Долгая краткосрочная память===
{{Main|Долгая краткосрочная память}}
[https://github.com/deeplearning4j/dl4j-examples/blob/master/dl4j-examples/src/main/java/org/deeplearning4j/examples/recurrent/character/LSTMCharModellingExample.java Пример] реализации рекуррентной нейронной сети, использующей механизм LSTM и натренированной на текстах Шекспира, с применением библиотеки <code>deeplearning4j</code>.
===Метод опорных векторов===
{{main|Метод опорных векторов (SVM)}}
Пример классификации с применением <code>smile.classification.SVM</code><ref>[https://haifengl.github.io/smile/api/java/smile/classification/SVM.html/ Smile, SVM]</ref>

<dependency>
<groupId>com.github.haifengl</groupId>
<artifactId>smile-core</artifactId>
<version>1.5.2</version>
</dependency>

'''import''' smile.classification.SVM;
'''import''' smile.data.NominalAttribute;
'''import''' smile.data.parser.DelimitedTextParser;
'''import''' smile.math.kernel.GaussianKernel;
'''import''' java.util.Arrays;

// read train & test dataset
'''var''' parser = new DelimitedTextParser();
parser.setResponseIndex(new NominalAttribute("class"), 0);
'''var''' train = parser.parse("USPS Train", this.getClass().getResourceAsStream("/smile/data/usps/zip.train"));
'''var''' test = parser.parse("USPS Test", this.getClass().getResourceAsStream("/smile/data/usps/zip.test"));
'''var''' classes = Arrays.stream(test.labels()).max().orElse(0) + 1;
// build SVM classifier
'''var''' svm = new SVM<>(new GaussianKernel(8.0), 5.0, classes, SVM.Multiclass.ONE_VS_ONE);
svm.learn(train.x(), train.labels());
svm.finish();
// calculate test error rate
'''var''' error = 0;
for (int i = 0; i < test.x().length; i++) {
if (svm.predict(test.x()[i]) != test.labels()[i]) {
error++;
}
}
System.out.format("USPS error rate = %.2f%%\n", 100.0 * error / test.x().length);

===Деревья решений, случайный лес===
{{Main|Дерево решений и случайный лес#Пример на языке Java}}

===Бустинг, Ada-boost===
{{main|Бустинг, AdaBoost#Пример на языке Java}}

===EM-алгоритм===
{{Main|EM-алгоритм|ll=EM-алгоритм [на 08.04.19 не создан]}}
Пример кластеризации с применением <code>weka.clusterers.EM</code><ref>[http://weka.sourceforge.net/doc.dev/weka/clusterers/EM.html/ Weka, EM]</ref>

<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.clusterers.ClusterEvaluation;
'''import''' weka.clusterers.EM;
'''import''' weka.core.Instances;
'''import''' java.io.BufferedReader;
'''import''' java.io.FileReader;
'''import''' java.util.Random;

//load data
'''var''' data = new Instances(new BufferedReader(new FileReader("data/bank-data.arff")));
// new instance of clusterer
'''var''' model = new EM();
// build the clusterer
model.buildClusterer(data);
System.out.println(model);
'''var''' logLikelihood = ClusterEvaluation.crossValidateModel(model, data, 10, new Random(1));

===Уменьшение размерности===
{{Main|Уменьшение размерности#Пример на языке Java}}

===Байесовская классификация===
{{Main|Байесовская классификация#Пример на языке Java}}

===Метрический классификатор и метод ближайших соседей===
{{Main|Метрический классификатор и метод ближайших соседей#Пример на языке Java}}

==См. также==
*[[:Примеры кода на Scala|Примеры кода на Scala]]
*[[:Примеры кода на R|Примеры кода на R]][на 08.04.19 не создан]
*[[:Обзор библиотек для машинного обучения на Python|Обзор библиотек для машинного обучения на Python]]

== Примечания ==
<references/>
[[Категория: Машинное обучение]] [[Категория: Примеры кода]]

Обзор библиотек для машинного обучения на Python

2019-04-08T13:37:14Z

91.215.123.110: Исправил ссылку на примеры Java

Дерево решений и случайный лес

2019-04-08T12:50:51Z

91.215.123.110: Добавил Джява пример

Дерево решений {{---}} логический алгоритм классификации, решающий задачи классификации и регрессии. Представляет собой объединение логических условий в структуру дерева.

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

{{Определение
|id=def1.
|neat =
|definition=
'''Дерево решений''' (англ. ''decision tree, DT'') {{---}} алгоритм классификации <tex>a(x) = (V_{внутр}, v_0, V_{лист}, S_v, \beta_v)</tex>, задающийся деревом (связным ациклическим графом), где:
* <tex> V = V_{внутр} \cup V_{лист} </tex> {{---}} множество вершин , <tex>v_0 \in V</tex> {{---}} корень дерева;
* <tex> S_v : D_v \rightarrow V_v </tex> {{---}} функция перехода по значению предиката в множество детей вершины <tex>v</tex>;
* <tex> \beta_v : X \rightarrow D_v </tex> {{---}} предикат ветвления, <tex>v \in V_{внутр}</tex> и <tex>|D_v| < \infty</tex>;
* Для листьев <tex>v \in V_{лист}</tex> определена метка класса <tex>y_v \in Y</tex>.
}}
{{Определение
|id=def1
|neat =
|definition=
'''Бинарное дерево решений''' {{---}} частный случай дерева решений, для которого <tex> D_v = \{0,1\} </tex>.
}}
[[Файл:BinDT.jpg |300px|thumb|right|Классификация объекта <tex> x \in X </tex> бинарным решающим деревом]]

'''function''' classify(x):
<tex>v = v_0</tex>
'''if''' <tex>\beta_v(x) = 1 </tex>
<tex>v := R_v</tex>
'''else'''
<tex>v := L_v</tex>
'''return''' <tex>y_v</tex>

===Информативность ветвления===
Для того, чтобы оценивать качество разбиения объектов по предикату <tex>\beta</tex>, введем понятие ''информационного выигрыша'' разбиения. 
Сначала оценим распределение значений классов объектов внутри каждого множества из разбиения, введя понятие ''меры неопределенности распределения''.
{{Определение
|id=def1
|neat =
|definition=
'''Частотная оценка вероятности класса <tex>y</tex> в вершине <tex>v \in V_{внутр}</tex> ''': 
<tex>p_y = P(y | x \in U) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}[y_i = y]</tex>
}}

{{Определение
|id=def1
|neat =
|definition=
'''Мера неопределенности (англ. ''impurity'') распределения <tex>p_y</tex>''': 
* минимальна, когда <tex>p_y \in \{0,1\}</tex>;
* максимальна, когда <tex>p_y = \frac{1}{|Y|}</tex> для всех <tex>y \in Y</tex>;
* не зависит от перенумерации классов
<tex>Ф(U) = \sum\nolimits_{y \in Y} p_y L(p_y) = \frac{1}{|U|} \sum\nolimits_{x_i \in U}L(P(y_i | x_i \in U)) \rightarrow min</tex>, где <tex>L(p)</tex> убывает и <tex>L(1) = 0</tex>, например: <tex>-log_2(p)</tex>, <tex>1 - p</tex>, <tex>1 - p^2</tex>
}}

Примерами мер неопределенности распределения являются:
* Энтропия: <tex>Ф(U) = -\sum\limits_{i}^N p_i log_2p_i</tex>, определяется для каждого множества из разбиения, <tex>N</tex> {{---}} количество возможных классов, и <tex>p_i</tex> {{---}} вероятность объекта принадлежать <tex> i</tex>-ому классу.
* Критерий Джини: <tex>Ф(U) = \sum\nolimits_{i != j}p_i p_j = \sum\nolimits_{i}p_i*(1-p_i)</tex>, максимизацию этого критерия можно интерпретировать как максимизацию числа пар объектов одного класса, оказавшихся после разбиения в одном множестве. 

Теперь определим суммарную ''неопределенность распределения'' в разбиении.
{{Определение
|id=def1
|neat =
|definition=
'''Неопределенность распределения <tex>P(y_i | x_i \in U_{\beta(x_i)})</tex> после ветвления вершины <tex>v</tex> по предикату <tex>\beta</tex> и разбиения <tex>U = \bigcup_{k \in D_v} U_k</tex>''': 
<tex>Ф(U_0, ... ,U_{D_v}) = \frac{1}{|U|} \sum\nolimits_{k \in D_v} \sum\nolimits_{x_i \in U_k}L(P(y_i | x_i \in U_k)) = \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k)</tex>
}}

''Информационный выигрыш'' от разбиения определяется как изменение неопределенности в системе.
{{Определение
|id=def1
|neat =
|definition=
'''Информационный выигрыш от разбиения по предикату <tex>\beta</tex>''' 
<tex>Gain(\beta, U) = Ф(U) - Ф(U_1, ... ,U_{|D_v|}) = Ф(U) - \sum\nolimits_{k \in D_v} \frac{|U_k|}{|U|}Ф(U_k) \rightarrow max_{\beta \in B} </tex>
}}

=== Рекурсивный алгоритм построения бинарного дерева решений ID3 ===
Покажем идею построения дерева решения на частном случае бинарного дерева. Алгоритм <tex>ID3</tex> (англ. ''Induction of Decision Tree'') заключается в последовательном дроблении выборки на две части до тех пор, пока в каждой части не окажутся объекты только одного класса. Разделение производится по предикату <tex>\beta</tex>, который выбирается из множества элементарных предикатов. На практике в качестве элементарных предикатов чаще всего берут простые пороговые условия вида <tex>\beta(x) = [f_j(x) >= d_j]</tex>.
 Проще всего записать этот алгоритм в виде рекурсивной процедуры <tex>ID3</tex>, которая строит дерево по заданной подвыборке <tex>U</tex> и возвращает его корневую вершину.

1:'''function''' ID3(<tex>U</tex>):
2: '''if''' <tex>for all</tex> <tex>u \in U</tex>: <tex>y_u = y</tex>, <tex>y \in Y</tex>
// создать листовую вершину <tex>v</tex> c меткой класса <tex>y_v</tex> 
3: v = createLeafVertex(<tex>y_v</tex>)
4: '''return''' v
// найти предикат с максимальным информационным выигрышом 
<tex>\beta= \mathrm{arg}\max_{\beta\in B} </tex> Gain(<tex>\beta</tex>, <tex>U</tex>)
// разбить выборку на две части <tex>U = U_0 \cup U_1</tex> по предикату <tex>\beta</tex> 
5: <tex>U_0 := \{x \in U: \beta(x) = 0\}</tex>
6: <tex>U_1 := \{x \in U: \beta(x) = 1\}</tex>
7: '''if''' <tex>U_0 = \emptyset</tex> || <tex>U_1 = \emptyset</tex>
// найти класс, в котором находится большинство объектов из <tex>U</tex> 
8: <tex>y_v</tex> = majorClass(<tex>U</tex>)
9: v = createLeafVertex(<tex>y_v</tex>)
'''else'''
// создать внутреннюю вершину <tex>v</tex>
10: v = createVertex()
11: <tex>\beta_v = \beta</tex>
12: <tex>S_0</tex> = ID3(<tex>U_0</tex>)
13: <tex>S_1</tex> = ID3(<tex>U_1</tex>)
14: '''return''' <tex>v</tex>

== Редукция решающих деревьев ==
Суть редукции (англ. ''pruning'') состоит в удалении поддеревьев, имеющих недостаточную статистическую надёжность. При этом дерево перестаёт безошибочно классифицировать обучающую выборку, зато качество классификации новых объектов, как правило, улучшается. Рассмотрим наиболее простые варианты редукции.

===Предредукция===
Предредукция (англ. ''pre-pruning'') или критерий раннего останова досрочно прекращает дальнейшее ветвление в вершине дерева, если информативность <tex>I(\beta, U)</tex> для всех возможных предикатов <tex>\beta</tex> не дотягивает до заданного порогового значения <tex>I_0</tex>. 
Для этого на шаге 8 алгоритма <tex>ID3</tex> условие <tex>U_0 = \emptyset</tex> или <tex>U_1 = \emptyset</tex> заменяется условием <tex>I(\beta, U) <= I_0 </tex>. Порог <tex>I_0 </tex> является управляющим параметром метода. 
Предредукция считается не самым эффективным способом избежать переобучения, так как жадное ветвление по-прежнему остаётся глобально неоптимальным. Более эффективной считается cтратегия постредукции.

===Постредукция===
Постредукция (англ. ''post-pruning'') просматривает все внутренние вершины дерева и заменяет отдельные вершины либо одной из дочерних вершин (при этом вторая дочерняя удаляется), либо терминальной вершиной. Процесс замен продолжается до тех
пор, пока в дереве остаются вершины, удовлетворяющие критерию замены. 
''Критерием замены'' является сокращение числа ошибок на контрольной выборке, отобранной заранее, и не участвовавшей в обучении дерева. Стандартная рекомендация — оставлять в контроле около 30% объектов. 
Для реализации постредукции контрольная выборка <tex>X^k</tex> пропускается через
построенное дерево. При этом в каждой внутренней вершине <tex>v</tex> запоминается подмножество <tex>S_v \subseteq X_k</tex> попавших в неё контрольных объектов. Если <tex>S_v = \emptyset </tex>, то вершина <tex>v</tex> считается ненадёжной и заменяется терминальной по ''мажоритарному правилу'': 
в качестве <tex>y_v</tex> берётся тот класс, объектов которого больше всего в обучающей подвыборке <tex>U</tex>, пришедшей в вершину <tex>v</tex>. 
Затем для каждой внутренней вершины <tex>v</tex> вычисляется число ошибок, полученных при классификации выборки <tex>S_v</tex> следующими способами: 
* <tex>r(v)</tex> — классификация поддеревом, растущим из вершины <tex>v</tex>;
* <tex>r_L(v)</tex> — классификация поддеревом левой дочерней вершины <tex>L_v</tex>;
* <tex>r_R(v)</tex> — классификация поддеревом правой дочерней вершины <tex>R_v</tex>;
* <tex>r_c(v)</tex> — отнесение всех объектов выборки <tex>S_v</tex> к классу <tex>y \in Y</tex>. 
Эти величины сравниваются, и в зависимости от того, какая из них оказалась
минимальной, принимается, соответственно, одно из четырёх решений: 
* сохранить поддерево вершины <tex>v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом левой дочерней вершины <tex>L_v</tex>;
* заменить поддерево вершины <tex>v</tex> поддеревом правой дочерней вершины <tex>R_v</tex>;
* заменить поддерево <tex>v</tex> терминальной вершиной класса <tex>y_v = \mathrm{arg}\min_{y\in Y}r_c(v) </tex>.

== Алгоритмы построения деревьев решения ==
Недостатки рассмотренного алгоритма ID3:
* Применим только для дискретных значений признаков;
* Переобучение;
* На каждом шаге решение принимается по одному атрибуту.

=== Алгоритм [https://en.wikipedia.org/wiki/Predictive_analytics#Classification_and_regression_trees_.28CART.29 CART] (англ. ''Classification And Regression Trees'')===
* В отличие от ID3 работает и с непрерывными значениями признаков: на каждом шаге построения дерева последовательно сравнивает все возможные разбиения для всех атрибутов и выбирает наилучший атрибут и наилучшее разбиение для него. Разбивает объекты на две части;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

=== Алгоритм [https://en.wikipedia.org/wiki/C4.5_algorithm C4.5] ===
* Также работает и с непрерывными значениями признаков: на каждом шаге построения дерева выбирает правило разбиения по одному из признаков. Разбивает объекты на несколько частей по этому правилу, рекурсивно запускается из полученных подмножеств;
* Использует редукцию для избежания переобучения;
* Обрабатывает пропущенные или аномальные значения признаков.

== Случайный лес ==
Случайный лес {{---}} один из примеров объединения классификаторов в [[Виды_ансамблей|ансамбль]]. 
Алгоритм построения случайного леса, состоящего из <tex>N</tex> деревьев на основе обучающей выборки <tex>X</tex> такой:
'''for''' (n: 1,...,N):
// сгенерировать выборку <tex>X_n</tex> c помощью [[Виды_ансамблей#Бутстрэп|бутстрэпа]]
<tex>X_n</tex> = bootstrap(<tex>X</tex>)
// построить решающее дерево <tex>t_n</tex> по выборке <tex>X_n</tex>
<tex>t_n</tex> = ID3(<tex>X_n</tex>) 

Итоговый классификатор {{---}} <tex>a(x) = \frac{1}{N} \sum\limits_{i = 1}^{N} t_i(x)</tex>. Для задачи классификации мы выбираем решение по большинству результатов, выданных классификаторами, а в задаче регрессии {{---}} по их среднему значению. 

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

==Примеры кода==
===Примеры на языке Python===
*Для решения задач классификации и регрессии используют [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier DecisionTreeClassifier], [https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html#sklearn.tree.DecisionTreeRegressor DecisionTreeRegressor];

*В '''sklearn.ensemble''' также представлены методы классификации, основанные на ансамблях, в том числе: [https://scikit-learn.org/stable/modules/ensemble.html#bagging бэггинг] и [https://scikit-learn.org/stable/modules/ensemble.html#forest случайный лес], которые были описаны выше.
 Так, в этом примере создается бэггинг ансамбль из классификаторов '''KNeighborsClassifier''', каждый из которых обучен на случайных подмножествах из 50% объектов из обучающей выборки, и 50% случайно выбранных признаков.

'''from''' sklearn.ensemble '''import''' BaggingClassifier
'''from''' sklearn.neighbors '''import''' KNeighborsClassifier
bagging = BaggingClassifier(KNeighborsClassifier(), max_samples=0.5, max_features=0.5)

Пример использования классификатора на случайном лесе:
Полную версию кода можно найти [https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html#sphx-glr-download-auto-examples-classification-plot-classifier-comparison-py| здесь]
'''from''' sklearn '''import''' RandomForestClassifier
'''from''' sklearn.datasets '''import''' make_classification
// сгенерируем случайную обучающую выборку с классификацией по n_classes классам
X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
random_state=1, n_clusters_per_class=1, n_classes=2)
// разбиваем выборку на обучающую и тестовую 
X = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
// создадим классификатор на случайном лесе, состоящим из n_estimators деревьев
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)

Результат классификации показан на рисунке.

[[Файл:RFC.png |800px|thumb|center|Классификация RandomForestClassifier. Кружочками изображены объекты обучающей выборки, крестиками тестовой выборки. Справа цветом выделены границы принятия решений, в правом нижнем углу {{---}} значение accuracy.]]

===Пример на языке Scala===
SBT зависимость:
libraryDependencies '''+=''' "com.github.haifengl" '''%%''' "smile-scala" '''%''' "1.5.2"
Пример классификации датасета и вычисления F1 меры<ref>[https://en.wikipedia.org/wiki/F1_score F1 мера]</ref> используя smile.classification.cart<ref>[https://haifengl.github.io/smile/classification.html#cart Smile, Decision Trees]</ref>:
'''import '''smile.classification._
'''import '''smile.data._
'''import '''smile.plot._
'''import '''smile.read
'''import '''smile.validation.FMeasure

'''val '''iris: AttributeDataset = read.table("iris.csv", delimiter = ",", response = Some(('''new '''NumericAttribute("class"), 2)))
'''val '''x: Array[Array['''Double''']] = iris.x()
'''val '''y: Array['''Int'''] = iris.y().map(_.toInt)
'''val '''dt: DecisionTree = cart(x, y, 1000)
'''val '''predictions: Array['''Int'''] = x.map(dt.predict)
'''val '''f1Score = '''new '''FMeasure().measure(predictions, y)
plot(x, y, dt)

===Пример на языке Java===
Пример классификации с применением <code>weka.classifiers.trees.RandomForest</code><ref>[http://weka.sourceforge.net/doc.dev/weka/classifiers/trees/RandomForest.html Weka, Random Forest]</ref>

Maven зависимость:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.0</version>
</dependency>

'''import''' weka.classifiers.evaluation.Evaluation;
'''import''' weka.classifiers.trees.RandomForest;

// read dataset
'''var''' trainingDataSet = getDataSet(...);
'''var''' testingDataSet = getDataSet(...);
// create random forest classifier
'''var''' forest = new RandomForest();
forest.setMaxDepth(15);
forest.setNumFeatures(2);
forest.buildClassifier(trainingDataSet);
// evaluate the model on test dataset and print summary
'''var''' eval = new Evaluation(trainingDataSet);
eval.evaluateModel(forest, testingDataSet);
System.out.println(eval.toSummaryString());

== См. также ==
* [[Виды ансамблей]]

== Источники информации ==
# [http://www.machinelearning.ru/wiki/images/3/3e/Voron-ML-Logic.pdf Логические алгоритмы классификации] {{---}} Лекция К. В. Воронцова
# [https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-5-ensembles-of-algorithms-and-random-forest-8e05246cbba7 Случайный лес] {{---}} статья на Medium, Yury Kashnitskiy
# [https://scikit-learn.org/stable/modules/tree.html Деревья решений] {{---}} scikit-learn.org
#[https://scikit-learn.org/stable/modules/ensemble.html Ансамбли классификаторов] — scikit-learn.org.

[[Категория: Машинное обучение]]
[[Категория: Классификация и регрессия]]