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

Эмммм, в этом семестре я закончил курс Эндрю Нг по машинному обучению на Coursera. Меня всегда не впечатлял этот курс, но я случайно зарегистрировался и подал заявку на финансовую помощь.После окончания курса я могу получить сертификат бесплатно (продается за несколько сотен долларов), а также я отправлю подлинный Matlab Online во время Конечно, эта серия случайных (профессиональных) естественных (мелких) вещей (удобных) (адаптивных) побудила меня начать чистить этот класс. А потом — так вкусно пахнет~! Этот класс действительно является хорошим введением в машинное обучение, и неудивительно, что так много людей рекомендуют его.

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

Низкая заметка.GitHub.IO/categories/…

Эти заметки были объединены в эту статью.

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

контролируемое обучение

Обучение с учителем обучается на данных x и y.

проблема регрессии

Чтобы делать прогнозы, диапазон представляет собой непрерывное число (например, интервал$[0,100]$)

математическая модель:

• функция предсказания:

• Запрашиваемые параметры:$\theta=\left[\begin{array}{c}\theta_0 & \theta_1 & \ldots & \theta_n\end{array}\right]$

• функция стоимости:

?Реализация кода:

  function J = computeCostMulti(X, y, theta)
  %COMPUTECOSTMULTI Compute cost for linear regression with multiple variables
  %   J = COMPUTECOSTMULTI(X, y, theta) computes the cost of using theta as the
  %   parameter for linear regression to fit the data points in X and y
  
  m = length(y); % number of training examples
  
  J = 0;
  
  J = 1 / (2*m) * (X*theta - y)' * (X*theta - y);
  
  % or less vectorizedly: 
  % predictions = X * theta;
  % sqrErrors = (predictions - y) .^ 2;
  % J = 1 / (2*m) * sum(sqrErrors);
  
  end

• оптимизировать цель: найти набор$\theta$сделать$J$минимум.

Решение:

градиентный спуск

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

Векторное представление:$\theta=\theta-\frac{\alpha}{m}X^T(h_\theta(X)-Y)$

?Реализация кода:

function [theta, J_history] = gradientDescentMulti(X, y, theta, alpha, num_iters)
%GRADIENTDESCENTMULTI Performs gradient descent to learn theta
%   theta = GRADIENTDESCENTMULTI(x, y, theta, alpha, num_iters) updates theta by
%   taking num_iters gradient steps with learning rate alpha

m = length(y); % number of training examples
J_history = zeros(num_iters, 1);

for iter = 1:num_iters

    predictions = X * theta;
    errors = (predictions - y);
    theta = theta - alpha / m * (X' * errors);
    
    % Save the cost J in every iteration    
    J_history(iter) = computeCostMulti(X, y, theta);

end

end

нормальное уравнение

?Реализация кода:

function [theta] = normalEqn(X, y)
%NORMALEQN Computes the closed-form solution to linear regression 
%   NORMALEQN(X,y) computes the closed-form solution to linear 
%   regression using the normal equations.

theta = zeros(size(X, 2), 1);

theta = pinv(X' * X) * X' * y;

end

Здесь мы используем псевдоинверсию, чтобы обеспечить правильную работу. обычно вызывают$X^TX$Причинами необратимости являются:

1. Существуют редуцируемые признаки, то есть, если два или более признака связаны линейно, только один из них может быть решен путем удаления других. (например, есть размер дома в футах ^ 2 и размер дома в метрах ^ 2, где мы знаем, что 1 метр = 3,28 фута)
2. Слишком много заданных функций, ($m \le n$) Некоторые неважные функции могут быть удалены (рассмотрите алгоритм PCA)

Градиентный спуск против нормального уравнения

	Gradient Descent	Normal Equation
Нужно выбрать альфу	✅	-
третья сторона	✅	-
временная сложность	$O(kn^2)$	попрошайничество$X^TX$Псевдоинверсия$O(n^3)$
Когда n достаточно велико	может работать	очень медленный или даже неисчислимый

На самом деле, когда$n>10,000$, мы обычно предпочитаем использовать градиентный спуск, в противном случае нормальные уравнения обычно работают лучше.

Примечание. Масштабирование функций

Мы можем заставить градиентный спуск работать быстрее, сделав входные значения примерно в пределах определенного диапазона, например, мы можем изменить все значения на$[-1,1]$В то же время мы также можем сделать разрыв между входными значениями не слишком большим путем обработки (например, входное значение имеет большой разрыв, такой как 0,000001 и 1 одновременно, что повлияет на эффективность градиента спуск).

На практике мы обычно хотим убедиться, что значения переменных$[-3,-\frac{1}{3}) \cup (+\frac{1}{3}, +3]$значение в этом диапазоне.

Для достижения этой цели мы делаем следующее:

1. Feature scaling

2. Mean normalizaton

Соедините две операции вместе, а именно:

в,$\mu_i$является средним значением признака (i),$s_i$это диапазон значений.

?Реализация кода:

function [X_norm, mu, sigma] = featureNormalize(X)
%FEATURENORMALIZE Normalizes the features in X 
%   FEATURENORMALIZE(X) returns a normalized version of X where
%   the mean value of each feature is 0 and the standard deviation
%   is 1. This is often a good preprocessing step to do when
%   working with learning algorithms.

X_norm = X;
mu = zeros(1, size(X, 2));
sigma = zeros(1, size(X, 2));

mu = mean(X);
sigma = std(X);
X_norm = (X - mu) ./ sigma;

end

проблема классификации

Делайте прогнозы с диапазоном дискретных конкретных значений (например, 0 или 1; 0/1/2/3)

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

Предположим, функция:

в,$g(z)$Названная функцией Симоида или логистической функцией, ее график выглядит следующим образом:

?Реализация кода:

function g = sigmoid(z)
%SIGMOID Compute sigmoid functoon
%   J = SIGMOID(z) computes the sigmoid of z.

g = 1.0 ./ (1.0 + exp(-z));
end

Приведенную выше формулу можно упростить до:

$h_\theta$Выходом является вероятность того, что прогнозируемое значение равно 1, и выполняются следующие два уравнения:

граница решения: Граница решения логистической регрессии состоит в том, чтобы разделить регион в$y=0$и$y=1$Гиперплоскость из двух частей.

Граница решения определяется функцией гипотезы. Это связано с тем, что для завершения классификации необходимо использовать$h_\theta$вывод, чтобы определить, является ли результат 0 или 1. Установите 0,5 в качестве отсечки, то есть:

Из свойств функции Simoid приведенная выше формула эквивалентна:

Тогда для заданного множества$\theta$,Например$\theta=\left[\begin{array}{c}5\\-1\\0\end{array} \right]$,имеют$y=1$если и только если$5+(-1)x_1+0x_2 \ge 0$, то граница решения$x_1=5$.

Границы решений также могут быть такими сложными, как:

модель логистической регрессии:

Векторное представление:

градиентный спуск:

Векторное представление:

?Реализация кода (с использованием расширенной оптимизации):

1. поставка$J(\theta), \frac{\partial}{\partial\theta_j}J(\theta)$

function [J, grad] = costFunction(theta, X, y)
%COSTFUNCTION Compute cost and gradient for logistic regression
%   J = COSTFUNCTION(theta, X, y) computes the cost of using theta as the
%   parameter for logistic regression and the gradient of the cost
%   w.r.t. to the parameters.

m = length(y); % number of training examples

J = 0;
grad = zeros(size(theta));

h = sigmoid(X*theta);

J = 1/m * (-y'*log(h) - (1-y)'*log(1-h));

grad = 1/m * X'*(h-y);

end

2. Вызовите функцию расширенной оптимизации, чтобы решить проблему оптимизации:

options = optimset('GradObj', 'on', 'MaxIter', 100);
initialTheta = zeros(2, 1);

[optTheta, functionVal, exitFlag] = fminunc(@costFunction, initialTheta, options);

многомерная классификация

Мы выполняем многомерную классификацию, используя ряд единичных (логических) классификаций:

Примечание: переобучение

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

Методы решения проблемы переобучения:

1. Уменьшить количество функций (PCA)

2. Регуляризация: добавление к функции стоимости$\theta$вес:

   $\mathop{min}\limits_{\theta} \dfrac{1}{2m}\ \sum_{i=1}^m (h_\theta(x^{(i)}) - y^{(i)})^2 + \lambda\ \sum_{j=1}^n \theta_j^2$

   Уведомление,$\theta_0$— постоянный член, который мы добавили, и его не следует регуляризировать.

   Код:

   function [J, grad] = lrCostFunction(theta, X, y, lambda)
   %LRCOSTFUNCTION Compute cost and gradient for logistic regression with 
   %regularization
   %   J = LRCOSTFUNCTION(theta, X, y, lambda) computes the cost of using
   %   theta as the parameter for regularized logistic regression and the
   %   gradient of the cost w.r.t. to the parameters. 
   
   m = length(y); % number of training examples
   
   J = 0;
   grad = zeros(size(theta));
   
   % Unregularized cost function & gradient for logistic regression
   h = sigmoid(X * theta);
   J = 1/m * (-y'*log(h) - (1-y)'*log(1-h));
   grad = 1/m * X'*(h-y);
   
   % Regularize
   temp = theta;
   temp(1) = 0;
   J = J + lambda/(2*m) * sum(temp.^2);
   grad = grad + lambda/m * temp;
   
   grad = grad(:);
   
   end

Нейронные сети

Первый слой — это набор данных, называемый входным слоем, который можно рассматривать как$a^{(0)}$; В середине есть несколько скрытых слоев, а конечным результатом является функция предсказания, которая называется выходным слоем.

Предполагая, что есть c слоев, тогда:

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

многомерная классификация

Настройка нейронной сети

Notation	Represent
$L$	Общее количество слоев в нейронной сети
$s_l$	первое$l$Количество узлов в слое (не считая элементов смещения$a_0$)
$K$	Количество выходных узлов

функция стоимости:

Алгоритм обратного распространения:

Примечание: в приведенной выше формуле$.*$Представляет поэлементное умножение в Matlab/Octave.

Использование обратного распространения:

Рассмотрим несколько задействованных методов:

• Расширение параметра: Чтобы использовать функцию оптимизации, нам нужно преобразовать все$\Theta$Расширение матрицы и объединение в длинный вектор:

thetaVector = [ Theta1(:); Theta2(:); Theta3(:) ];
deltaVector = [ D1(:); D2(:); D3(:) ];

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

Theta1 = reshape(thetaVector(1:110),10,11)
Theta2 = reshape(thetaVector(111:220),10,11)
Theta3 = reshape(thetaVector(221:231),1,11)

• Проверка градиента: эксплойт$\frac{\partial}{\partial\Theta_j}J(\Theta) \approx \frac{J(\Theta_1,...,\Theta_j+\epsilon,...,\Theta_n)-J(\Theta_1,...,\Theta_j-\epsilon,...,\Theta_n)}{2\epsilon}$Возьмем небольшой район, например$\epsilon=10^{-4}$, вы можете проверить, является ли градиент, который мы получаем с обратнойпропрагацией, правильно (если он правильно, HODOPOPOXOX - Deltavector Holds). Код:

epsilon = 1e-4;
for i = 1 : n
	thetaPlus = theta;
	thetaPlus(i) += epsilon;
	thetaMinus = theta;
	thetaMinus(i) += epsilon;
	gradApprox(i) = (J(thetaPlus) - J(thetaMinus)) / (2*epsilon);
end

• Немедленная инициализация: В начале$\Theta_{ij}^{(l)}$Случайная инициализация должна гарантировать, что значение случайного значения находится в пределах$[-\epsilon,\epsilon]$диапазон (это$\epsilon$Не связано с проверкой градиента). Код:

# If the dimensions of Theta1 is 10x11, Theta2 is 10x11 and Theta3 is 1x11.

Theta1 = rand(10,11) * (2 * INIT_EPSILON) - INIT_EPSILON;
Theta2 = rand(10,11) * (2 * INIT_EPSILON) - INIT_EPSILON;
Theta3 = rand(1,11) * (2 * INIT_EPSILON) - INIT_EPSILON;

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

1. случайная инициализация
2. распространяться вперед$h_\Theta(x^{(i)})$любому$x^{(i)}$
3. Вычислить функцию стоимости
4. Вычислите частные производные с помощью обратного распространения
5. Используйте проверку градиента, чтобы убедиться в правильности обратного распространения. Если проблем нет, отключите функцию проверки градиента.
6. Используйте градиентный спуск или функции оптимизации, чтобы получить$\Theta$

?Реализация кода:

1. случайная инициализация

function W = randInitializeWeights(L_in, L_out)
%RANDINITIALIZEWEIGHTS Randomly initialize the weights of a layer with L_in
%incoming connections and L_out outgoing connections
%   W = RANDINITIALIZEWEIGHTS(L_in, L_out) randomly initializes the weights 
%   of a layer with L_in incoming connections and L_out outgoing 
%   connections. 
%
%   Note that W should be set to a matrix of size(L_out, 1 + L_in) as
%   the first column of W handles the "bias" terms
%

W = zeros(L_out, 1 + L_in);

% epsilon_init = 0.12
epsilon_init = sqrt(6 / (L_in + L_out));
W = rand(L_out, 1 + L_in) * (2 * epsilon_init) - epsilon_init;

end

2. Вычислительная стоимость

function [J grad] = nnCostFunction(nn_params, ...
                                   input_layer_size, ...
                                   hidden_layer_size, ...
                                   num_labels, ...
                                   X, y, lambda)
%NNCOSTFUNCTION Implements the neural network cost function for a two layer
%neural network which performs classification
%   [J grad] = NNCOSTFUNCTON(nn_params, hidden_layer_size, num_labels, ...
%   X, y, lambda) computes the cost and gradient of the neural network. The
%   parameters for the neural network are "unrolled" into the vector
%   nn_params and need to be converted back into the weight matrices. 
% 
%   The returned parameter grad should be a "unrolled" vector of the
%   partial derivatives of the neural network.
%

% Reshape nn_params back into the parameters Theta_1 and Theta_2, the weight matrices
% for our 2 layer neural network
Theta_1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
                 hidden_layer_size, (input_layer_size + 1));

Theta_2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
                 num_labels, (hidden_layer_size + 1));

% Setup some useful variables
m = size(X, 1);
K = num_labels;

J = 0;
Theta_1_grad = zeros(size(Theta_1));
Theta_2_grad = zeros(size(Theta_2));

% y(5000x1) -> Y(5000x10)
Y = zeros(m, K);
for i = 1 : m
    Y(i, y(i)) = 1;
end

% Feedforward
a_1 = X;
a_1_bias = [ones(m, 1), a_1];

z_2 = a_1_bias * Theta_1';
a_2 = sigmoid(z_2);
a_2_bias = [ones(m, 1), a_2];

z_3 = a_2_bias * Theta_2';
a_3 = sigmoid(z_3);
h = a_3;

% Cost Function
% for i = 1 : K
%     yK = Y(:, i);
%     hK = h(:, i);
%     J += 1/m * (-yK'*log(hK) - (1-yK)'*log(1-hK));

% J can be get by element-wise compute more elegantly.
J = 1/m * sum(sum((-Y.*log(h) - (1-Y).*log(1-h))));

% Regularize
J = J + lambda/(2*m) * (sum(sum(Theta_1(:, 2:end).^2)) + sum(sum(Theta_2(:, 2:end).^2)));

% Backpropagation

delta_3 = a_3 .- Y;
delta_2 = (delta_3 * Theta_2) .* sigmoidGradient([ones(m, 1), z_2]);
% sigmoidGradient: return g = sigmoid(z) .* (1 - sigmoid(z));
delta_2 = delta_2(:, 2:end);

Delta_1 = delta_2' * a_1_bias;
Delta_2 = delta_3' * a_2_bias;

Theta_1_grad = Delta_1 ./ m + lambda/m * [zeros(size(Theta_1, 1), 1), Theta_1(:, 2:end)];
Theta_2_grad = Delta_2 ./ m + lambda/m * [zeros(size(Theta_2, 1), 1), Theta_2(:, 2:end)];

% Unroll gradients
grad = [Theta_1_grad(:) ; Theta_2_grad(:)];

end

3. предсказывать

function p = predict(Theta1, Theta2, X)
%PREDICT Predict the label of an input given a trained neural network
%   p = PREDICT(Theta1, Theta2, X) outputs the predicted label of X given the
%   trained weights of a neural network (Theta1, Theta2)

% Useful values
m = size(X, 1);
num_labels = size(Theta2, 1);

p = zeros(size(X, 1), 1);

h1 = sigmoid([ones(m, 1) X] * Theta1');
h2 = sigmoid([ones(m, 1) h1] * Theta2');
[dummy, p] = max(h2, [], 2);

end

4. водить машину

input_layer_size  = 400;  % 20x20 Input Images of Digits
hidden_layer_size = 25;   % 25 hidden units
num_labels = 10;          % 10 labels, from 1 to 10   
                          % (note that we have mapped "0" to label 10)

fprintf('\nInitializing Neural Network Parameters ...\n')

load('Xy.mat');

fprintf('\nTraining Neural Network... \n')

%  value to see how more training helps.
options = optimset('MaxIter', 1000);

lambda = 1;

% Create "short hand" for the cost function to be minimized
costFunction = @(p) nnCostFunction(p, ...
                                   input_layer_size, ...
                                   hidden_layer_size, ...
                                   num_labels, X, y, lambda);

% Now, costFunction is a function that takes in only one argument (the
% neural network parameters)
[nn_params, cost] = fmincg(costFunction, initial_nn_params, options);

% Obtain Theta1 and Theta2 back from nn_params
Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ...
                 hidden_layer_size, (input_layer_size + 1));

Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ...
                 num_labels, (hidden_layer_size + 1));

pred = predict(Theta1, Theta2, X);

fprintf('\nTraining Set Accuracy: %f\n', mean(double(pred == y)) * 100);

Опорные векторные машины

оптимизировать цель:

когда$C$Когда значение относительно велико, эта цель оптимизации будет стремиться к тому, чтобы первый член суммирования стремился к нулю, так что цель оптимизации становится:

По знанию евклидова пространства:

Вышеприведенная формула может быть выражена как:

SVM выберет самый большой разрыв:

ядерный метод

Столкнулся со следующими проблемами классификации:

Мы можем использовать полиномы для регрессии, например, когда$\theta_0+\theta_1x_1+\theta_2x_2+\theta_3x_1x_2+\theta_4x_1^2+\theta_5x_2^2+\cdots\ge 0$прогноз времени$y=1$;

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

здесь$f_1=x_1,f_2=x_2,f_3=x_1x_2,f_4=x_1^2,...$

мы используем$f_i$Полином заменяется, и проблемы со старшими членами избегаются, так как определить$f_i$? Общая идея такова:

Для удобства описания предположим, что у нас есть только$x_0,x_1,x_2$, и предназначен только для построения$f_1,f_2,f_3$. Ну, несмотря ни на что$x_0$(зачетный срок), мы начинаем с$x_1$-$x_2$Выберите 3 точки на изображении , обозначенные как$l^{(1)},l^{(2)},l^{(3)}$, назови этоотмеченная точка. дать$x$, получаем набор$f_i$:

Конкретная функция подобия здесь называетсяФункция ядра, функция ядра варьируется. То, что мы пишем здесь, очень часто используется$\exp(-\frac{\sum_{j=1}^n(x_j-l_j^{(i)})^2}{2\sigma^2})$, называемый Gaussian Kernel, код которого реализован следующим образом:

Из этого метода мы знаем, что задано$x$, для каждого$l^{(i)}$мы получим$f_i$, удовлетворять:

1. когда$x$около$l^{(i)}$Время

2. когда$x$держаться подальше$l^{(i)}$Время

$\sigma$выбор повлияет$f_i$значение варьируется$x$держаться подальше$l^{(i)}$и скорость снижения,$\sigma^2$чем больше$f_i$Уменьшать медленнее:

Используя метод ядра, мы можем сделать этот прогноз:

тогда и только тогда, когда дано$x$около$l^{(1)}$или$l^{(2)}$предсказывает 1, если это так, и 0 в противном случае.

Ядра, используемые в SVM

1. данный тренировочный набор$(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),...,(x^{(m)},y^{(m)})$

2. Выберите маркерные точки:$l^{(i)}=x^{(i)} \quad \textrm{for }i=1,2,\cdots,m$

3. для образца$x$, вычисление ядра:$f_i=\mathop{\textrm{similarity}}(x,l^{(i)}) \quad \textrm{for }i=1,2,\cdots,m$

4. сделать$f=[f_0,f_1,f_2,\cdots,f_m]^T$,в$f_0 \equiv 1$.

предсказывать:

• данный$x$,рассчитать$f\in\R^{m+1}$
• предсказывать$y=1$если$\theta^Tf=\theta_0f_0+\theta_1f_1+\cdots\ge 0$

тренироваться:

выполнить:

Мы можем использовать такие библиотеки, как liblinear, libsvm, чтобы получить параметры SVM.$\theta$, чтобы использовать эти библиотеки, нам обычно нужно сделать следующее:

• выберите параметры$C$
• выбрать функцию ядра
  • No kernel(т.е. линейное ядро, то есть логистическая регрессия: Predict$y=1$ if $\theta^Tx\ge0$), зап большой м маленький(чтобы избежать переобучения)
  • Gaussian kernel($f_i=\exp(-\frac{||x-l^{(i)}||^2}{2\sigma^2})\textrm{ where } l^{(i)}=x^{(i)} \textrm{ for } i=1,\cdots,m$) относится км большой н маленькийслучай (могут быть установлены более сложные нелинейные оценки)
• Предоставьте функцию ядра (например, ядро ​​Гаусса):

Примечание. Используйте Gaussian Kernel, чтобы обеспечить характерный масштаб!

?Реализация кода бескорпусной функции:

function sim = linearKernel(x1, x2)
%LINEARKERNEL returns a linear kernel between x1 and x2
%   sim = linearKernel(x1, x2) returns a linear kernel between x1 and x2
%   and returns the value in sim

% Ensure that x1 and x2 are column vectors
x1 = x1(:); x2 = x2(:);

% Compute the kernel
sim = x1' * x2;  % dot product

end

?Реализация кода ядра Гаусса:

function sim = gaussianKernel(x1, x2, sigma)
%RBFKERNEL returns a radial basis function kernel between x1 and x2
%   sim = gaussianKernel(x1, x2) returns a gaussian kernel between x1 and x2
%   and returns the value in sim

% Ensure that x1 and x2 are column vectors
x1 = x1(:); x2 = x2(:);

sim = 0;

sim = exp(-sum((x1 - x2).^2) / (2 * sigma ^ 2));

end

?Пример SVM:

% Load X, y, Xtest and ytest
load('data.mat');

% SVM Parameters
C = 1;         % C = 1 ~ 100 is fine
sigma = 0.1;    % sigma = 0.03 ~ 0.1 gives somewhat good boundary, less is better

% We set the tolerance and max_passes lower here so that the code will run
% faster. However, in practice, you will want to run the training to
% convergence.
model= svmTrain(X, y, C, @(x1, x2) gaussianKernel(x1, x2, sigma)); 
p = svmPredict(model, Xtest);

fprintf('Test Accuracy: %f\n', mean(double(p == ytest)) * 100);

многомерная классификация

Логистическая регрессия против нейронных сетей против SVM

$n$= количество функций ($x\in\R^{n+1}$)

$m$= количество обучающих выборок

• n больше, чем m (например,$n=10,000, m=10 \sim 1000$)
  • Логистическая регрессия или безъядерный SVM
• n мало, m умеренно (например,$n=1\sim1000,m=50,000$)
  • SVM с ядром Гаусса
• n маленькое, m большое
  • Создайте/добавьте функции, затем используйте логистическую регрессию или безъядерную SVM

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

неконтролируемое обучение

Неконтролируемому обучению даются только данные x, а не y.

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

Разделите кучу вещей на K стопок автоматически.

входить:

• $K$: количество кластеров
• $\{x^{(1)},x^{(2)},\cdots,x^{(m)}\}$:Обучающий набор

вывод:

• $K$классы

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

Функция стоимости:

оптимизировать цель:

Алгоритмы для получения лучшего решения (не обязательно оптимального решения):

$K$выбор:

1. Более практические требования легко доступны;
2. Выберите точку перегиба:

?Код

1. Найдите ближайший учебный центр:

function idx = findClosestCentroids(X, centroids)
%FINDCLOSESTCENTROIDS computes the centroid memberships for every example
%   idx = FINDCLOSESTCENTROIDS (X, centroids) returns the closest centroids
%   in idx for a dataset X where each row is a single example. idx = m x 1 
%   vector of centroid assignments (i.e. each entry in range [1..K])
%

% Set K
K = size(centroids, 1);

idx = zeros(size(X,1), 1);

for i = 1 : size(X, 1)
    min_j = 0;
    min_l = Inf;
    for j = 1 : size(centroids, 1)
        l = sum((X(i, :) - centroids(j, :)) .^ 2);
        if l <= min_l
            min_j = j;
            min_l = l;
        end
    end
    idx(i) = min_j;
end

end

2. Вычислительный центр:

function centroids = computeCentroids(X, idx, K)
%COMPUTECENTROIDS returns the new centroids by computing the means of the 
%data points assigned to each centroid.
%   centroids = COMPUTECENTROIDS(X, idx, K) returns the new centroids by 
%   computing the means of the data points assigned to each centroid. It is
%   given a dataset X where each row is a single data point, a vector
%   idx of centroid assignments (i.e. each entry in range [1..K]) for each
%   example, and K, the number of centroids. You should return a matrix
%   centroids, where each row of centroids is the mean of the data points
%   assigned to it.
%

% Useful variables
[m n] = size(X);

centroids = zeros(K, n);

for i = 1 : K
    ck = find(idx == i);
    centroids(i, :) = sum(X(ck,:)) / size(ck, 1);
end

end

3. Запуск K-средних

function [centroids, idx] = runkMeans(X, initial_centroids, ...
                                      max_iters, plot_progress)
%RUNKMEANS runs the K-Means algorithm on data matrix X, where each row of X
%is a single example
%   [centroids, idx] = RUNKMEANS(X, initial_centroids, max_iters, ...
%   plot_progress) runs the K-Means algorithm on data matrix X, where each 
%   row of X is a single example. It uses initial_centroids used as the
%   initial centroids. max_iters specifies the total number of interactions 
%   of K-Means to execute. plot_progress is a true/false flag that 
%   indicates if the function should also plot its progress as the 
%   learning happens. This is set to false by default. runkMeans returns 
%   centroids, a Kxn matrix of the computed centroids and idx, a m x 1 
%   vector of centroid assignments (i.e. each entry in range [1..K])
% 若使用 plot_progress 需要额外的画图函数实现，这里没有给出.
%

% Set default value for plot progress
if ~exist('plot_progress', 'var') || isempty(plot_progress)
    plot_progress = false;
end

% Plot the data if we are plotting progress
if plot_progress
    figure;
    hold on;
end

% Initialize values
[m n] = size(X);
K = size(initial_centroids, 1);
centroids = initial_centroids;
previous_centroids = centroids;
idx = zeros(m, 1);

% Run K-Means
for i=1:max_iters
    
    % Output progress
    fprintf('K-Means iteration %d/%d...\n', i, max_iters);
    if exist('OCTAVE_VERSION')
        fflush(stdout);
    end
    
    % For each example in X, assign it to the closest centroid
    idx = findClosestCentroids(X, centroids);
    
    % Optionally, plot progress here
    if plot_progress
        plotProgresskMeans(X, centroids, previous_centroids, idx, K, i);
        previous_centroids = centroids;
        fprintf('Press enter to continue.\n');
        input("...");
    end
    
    % Given the memberships, compute new centroids
    centroids = computeCentroids(X, idx, K);
end

% Hold off if we are plotting progress
if plot_progress
    hold off;
end

end

4. Скрипт драйвера:

% Load an example dataset
load('data.mat');

% Settings for running K-Means
K = 3;
max_iters = 10;

% For consistency, here we set centroids to specific values
% but in practice you want to generate them automatically, such as by
% settings them to be random examples (as can be seen in
% kMeansInitCentroids).
initial_centroids = [3 3; 6 2; 8 5];

% Run K-Means algorithm. The 'true' at the end tells our function to plot
% the progress of K-Means
[centroids, idx] = runkMeans(X, initial_centroids, max_iters, true);
fprintf('\nK-Means Done.\n\n');

Уменьшение размерности PCA

Анализ основных компонентов: уменьшите n-мерные данные (проекцию) до k-мерных и опустите неважную часть (k

Алгоритм PCA:

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

   Обучающий набор:$x^{(1)},x^{(2)},\cdots,x^{(m)}$

   Предварительная обработка (масштабирование признаков и нормализация среднего):

   • $\mu_j=\frac{1}{m}\sum_{i=1}^m x_j^{(i)},\qquad s_j=\textrm{standard deviation of feature }j$

   • Replace each $x_j^{(i)}$ with $\frac{x_j-\mu_j}{s_j}$

2) уменьшение размерности

1. Вычислить ковариационную матрицу$\Sigma$(Эта матрица записывается как большая сигма, обратите внимание, чтобы отличить ее от знака суммирования):

2. попрошайничество$\Sigma$Собственные значения (фактически сингулярное разложение):[U, S, V] = svd(Sigma);
3. Из предыдущего шага svd получаем:

4. Полное уменьшение размерности:$x\in\R^n\to z\in\R^k$:

?Реализация кода:

% do feature scaling & mean normalization

Sigma = 1/m * X' * X;
[U, S, V] = svd(Sigma);

Ureduce = U(:, 1:K);
Z = X * Ureduce;

восстановление данных: восстановить исходные размеры данных ($z\in\R^k \to x_{approx}\in\R^n$):

В целом$x \neq x_{approx}$, мы можем только ожидать$x_{approx}$как можно ближе$x$.

$k$Выбор (количество основных компонентов)

Как правило, выбирайте$k$Для минимального значения, при котором справедливо следующее уравнение:

алгоритм:

аномальное обнаружение

Найдите выбросы из множества данных.

Описание проблемы: задан набор данных$\{x^{(1)},x^{(2)},\cdots,x^{(m)}\}$, путем обучения, судить$x_{test}$Разве это ненормально.

Для решения этой проблемы мы можем$p(x)$(Вероятность) Построить модель, выбрать критическое значение$\epsilon$,сделать:

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

Гауссово распределение

$x$Следуйте распределению Гаусса:$x \sim \mathcal{N}(\mu,\sigma^2)$

но,$x$Вероятность:

где параметры$\mu$и$\sigma$Определяется по следующей формуле (это формат, обычно используемый в машинном обучении, не обязательно такой же, как в математике):

?Реализация кода:

function [mu sigma2] = estimateGaussian(X)
%ESTIMATEGAUSSIAN This function estimates the parameters of a 
%Gaussian distribution using the data in X
%   [mu sigma2] = estimateGaussian(X), 
%   The input X is the dataset with each n-dimensional data point in one row
%   The output is an n-dimensional vector mu, the mean of the data set
%   and the variances sigma^2, an n x 1 vector
% 

% Useful variables
[m, n] = size(X);

mu = zeros(n, 1);
sigma2 = zeros(n, 1);

mu = mean(X);
sigma2 = var(X) * (m - 1) / m;

end

Отсюда мы можем получить алгоритм проверки исключений:

Алгоритм проверки аномалий

1. Выберите функции данных, которые, как считается, могут демонстрировать выборочные аномалии$x_i$
2. Расчетные параметры$\mu_1,\cdots,\mu_n,\sigma_1^2,\cdots,\sigma_n^2$

3. Для вновь предоставленных образцов$x$,рассчитать$p(x)$:

4. если$p(x)<\epsilon$, прогноз ненормальный.

Многомерное распределение Гаусса

параметр:

• $\mu\in\R^n$
• $\Sigma\in\R^{n\times n}$ (covariance matrix, Sigma = 1/m * X' * X;)

Расчет параметров:

?Реализация кода:

function p = multivariateGaussian(X, mu, Sigma2)
%MULTIVARIATEGAUSSIAN Computes the probability density function of the
%multivariate gaussian distribution.
%    p = MULTIVARIATEGAUSSIAN(X, mu, Sigma2) Computes the probability 
%    density function of the examples X under the multivariate gaussian 
%    distribution with parameters mu and Sigma2. If Sigma2 is a matrix, it is
%    treated as the covariance matrix. If Sigma2 is a vector, it is treated
%    as the \sigma^2 values of the variances in each dimension (a diagonal
%    covariance matrix)
%

k = length(mu);

if (size(Sigma2, 2) == 1) || (size(Sigma2, 1) == 1)
    Sigma2 = diag(Sigma2);
end

X = bsxfun(@minus, X, mu(:)');
p = (2 * pi) ^ (- k / 2) * det(Sigma2) ^ (-0.5) * ...
    exp(-0.5 * sum(bsxfun(@times, X * pinv(Sigma2), X), 2));

end

Проверка аномалий с помощью многомерного распределения Гаусса

1. Подгонка многомерного распределения Гаусса$p(x)$модель, через параметры:

2. для новых$x$, рассчитать:

3. если$p(x)<\epsilon$, прогноз ненормальный.

Выбор порога

через вычисление$F_1$значение, чтобы получить наилучшее соответствие$\epsilon$.

$F_1$Значение определяется точностью ($prec$) И напомнить($rec$) дает:

в:

• $tp$Да, истинные срабатывания: прогноз положительный, фактический также положительный
• $fp$да ложные срабатывания: предсказано положительное, фактически отрицательное
• $fn$да ложноотрицательные: прогнозируемый отрицательный, фактически положительный

?Реализация кода:

function [bestEpsilon bestF1] = selectThreshold(yval, pval)
%SELECTTHRESHOLD Find the best threshold (epsilon) to use for selecting
%outliers
%   [bestEpsilon bestF1] = SELECTTHRESHOLD(yval, pval) finds the best
%   threshold to use for selecting outliers based on the results from a
%   validation set (pval) and the ground truth (yval).
%

bestEpsilon = 0;
bestF1 = 0;
F1 = 0;

stepsize = (max(pval) - min(pval)) / 1000;
for epsilon = min(pval):stepsize:max(pval)

    cvPredictions = pval < epsilon;
    
    tp = sum((cvPredictions == 1) & (yval == 1));
    fp = sum((cvPredictions == 1) & (yval == 0));
    fn = sum((cvPredictions == 0) & (yval == 1));

    prec = tp / (tp + fp);
    rec = tp / (tp + fn);

    F1 = (2 * prec * rec) / (prec + rec);

    if F1 > bestF1
       bestF1 = F1;
       bestEpsilon = epsilon;
    end
end

end

Рекомендуемая система

Через рейтинги рекомендуйте новый контент пользователям.

Описание обозначения: (Предположим, что мы хотим порекомендовать фильм)

• $n_u$= количество пользователей
• $n_m$= количество фильмов
• $r(i,j)=1$Если пользователь$j$на пленке$i$Переоценен, иначе 0
• $y^{(i,j)}$= пользователь$j$дать фильм$i$Рейтинг (только если$r(i,j)=1$определено, когда)

Рекомендация на основе контента

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

• $r(i,j)=1$Если пользователь$j$на пленке$i$переоцененный
• $y^{(i,j)}$= пользователь$j$дать фильм$i$оценка (если определено)
• $\theta^{(j)}$Пользователь$j$параметры (вектор)
• $x^{(i)}$Кино$i$характеристика (вектор)

для пользователей$j$,Кино$i$, прогнозируемый счет:$(\theta^{(j)})^T(x^{(i)})$.

оптимизировать цель:

1. оптимизация$\theta^{(j)}$(для одного пользователя$j$параметры)

2. оптимизация$\theta^{(1)},\theta^{(2)},\cdots,\theta^{(n_u)}$(для всех пользователей)

Мы можем решить проблему с градиентным спуском:

Совместная фильтрация

В рекомендации по содержанию нам иногда трудно понять фильм (мы хотим что-то порекомендовать) Каковы характеристики ($x^{(i)}$), мы хотим, чтобы машинное обучение само находил функции, для чего используется совместная фильтрация.

Новая цель оптимизации: (Цель оптимизации в рекомендации на основе контента все еще необходимо учитывать)

• данный$\theta^{(1)},\theta^{(2)},\cdots,\theta^{(n_u)}$,учиться$x^{(i)}$:

• данный$\theta^{(1)},\theta^{(2)},\cdots,\theta^{(n_u)}$,учиться$x^{(1)},\cdots,x^{(n_m)}$:

Совместная фильтрация:

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

Мы можем думать о решении этой дилеммы следующим образом:

Первое случайное угадывание группы$\theta$, то используйте этот набор$\theta$чтобы получить набор$x$; получается с этим набором$x$можно оптимизировать$\theta$, оптимизированный$\theta$снова оптимизировать$x$... и продолжайте повторять этот процесс, мы можем ожидать получить набор$x$и$\theta$являются полностью оптимизированными решениями (на самом деле они со временем сойдутся).

Мы случайным образом инициализируем набор параметров, а затем повторяем вычисления туда и обратно.$\theta$и$x$, в конечном итоге получим решение, но это более хлопотно, мы можем сделать это более эффективно:

в то же времяоптимизация$x^{(1)},\cdots,x^{(n_m)}$и$\theta^{(1)},\cdots,\theta^{(n_u)}$:

Алгоритм совместной фильтрации:

1. будет$x^{(1)},\cdots,x^{(n_m)},\theta^{(1)},\cdots,\theta^{(n_u)}$Случайно инициализируется некоторым небольшим случайным значением
2. оптимизация$J(x^{(1)},\cdots,x^{(n_m)},\theta^{(1)},\cdots,\theta^{(n_u)})$
3. Для данного пользователя параметры для этого пользователя$\theta$, то используйте свойство фильма, полученное путем обучения$x$, мы можем предсказать, что пользователь, скорее всего, поставит оценку этому фильму:$\theta^Tx$.

матричная факторизация низкого ранга:

Мы видим, что наш окончательный прогноз выглядит так:

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

Тогда есть:

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

Найти похожие фильмы:

Нам часто нужны рекомендации и фильмы$i$похожие фильмы$j$, который можно найти так:

средняя нормализация:

В проблеме рекомендации фильмов, поскольку оценка всегда составляет от 1 до 5 (или другие диапазоны), нет масштабирования признаков, но можно выполнить среднюю нормализацию:

пользователям$j$, Кино$i$, предсказывать:

?Код:

1. Функция стоимости:

function [J, grad] = cofiCostFunc(params, Y, R, num_users, num_movies, ...
                                  num_features, lambda)
%COFICOSTFUNC Collaborative filtering cost function
%   [J, grad] = COFICOSTFUNC(params, Y, R, num_users, num_movies, ...
%   num_features, lambda) returns the cost and gradient for the
%   collaborative filtering problem.
%

% Unfold the U and W matrices from params
X = reshape(params(1:num_movies*num_features), num_movies, num_features);
Theta = reshape(params(num_movies*num_features+1:end), ...
                num_users, num_features);

            
J = 0;
X_grad = zeros(size(X));
Theta_grad = zeros(size(Theta));

h = X * Theta';
er = (h - Y) .* R;

J = 1/2 * sum(sum(er.^2));
X_grad = er * Theta;
Theta_grad = er' * X; 

% Regularized

J += lambda/2 *(sum(sum(Theta.^2)) + sum(sum(X.^2)));
X_grad += lambda * X;
Theta_grad += lambda * Theta;
grad = [X_grad(:); Theta_grad(:)];

end

2. средняя нормализация

function [Ynorm, Ymean] = normalizeRatings(Y, R)
%NORMALIZERATINGS Preprocess data by subtracting mean rating for every 
%movie (every row)
%   [Ynorm, Ymean] = NORMALIZERATINGS(Y, R) normalized Y so that each movie
%   has a rating of 0 on average, and returns the mean rating in Ymean.
%

[m, n] = size(Y);
Ymean = zeros(m, 1);
Ynorm = zeros(size(Y));
for i = 1:m
    idx = find(R(i, :) == 1);
    Ymean(i) = mean(Y(i, idx));
    Ynorm(i, idx) = Y(i, idx) - Ymean(i);
end

end

3. сценарий драйвера

%  Normalize Ratings
[Ynorm, Ymean] = normalizeRatings(Y, R);

%  Useful Values
num_users = size(Y, 2);
num_movies = size(Y, 1);
num_features = 10;

% Set Initial Parameters (Theta, X)
X = randn(num_movies, num_features);
Theta = randn(num_users, num_features);

initial_parameters = [X(:); Theta(:)];

% Set options for fmincg
options = optimset('GradObj', 'on', 'MaxIter', 100);

% Set Regularization
lambda = 10;
theta = fmincg (@(t)(cofiCostFunc(t, Ynorm, R, num_users, num_movies, ...
                                num_features, lambda)), ...
                initial_parameters, options);

% Unfold the returned theta back into U and W
X = reshape(theta(1:num_movies*num_features), num_movies, num_features);
Theta = reshape(theta(num_movies*num_features+1:end), ...
                num_users, num_features);

fprintf('Recommender system learning completed.\n');

p = X * Theta';
my_predictions = p(:,1) + Ymean;

---

EOF