From 3ca2d167caa25d5bd091a2c95d244aa82960119f Mon Sep 17 00:00:00 2001 From: Vergara Date: Fri, 4 Dec 2020 18:56:11 +0300 Subject: [PATCH] added em algorithm --- em.ipynb | 775 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 775 insertions(+) create mode 100644 em.ipynb diff --git a/em.ipynb b/em.ipynb new file mode 100644 index 0000000..ac8c360 --- /dev/null +++ b/em.ipynb @@ -0,0 +1,775 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# EM-алгоритм " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Задача:** Пусть в пространстве даны $n$ точек. Мы хотим их кластеризовать." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## K-means" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Вначале мы фиксируем число $k$. И рассмотрим следующий итеративный алгоритм, который делит точки на $k$ кластеров.\n", + "\n", + "\n", + "1. Вначале выбираем $k$ случайных из данных точек это будут центры кластеров вначале \n", + "2. Дальше повторяем следующий алгоритм\n", + " * Считаем для каждой точки ближайщий центр кластера. Относим эту точку к этому кластеру\n", + " * Пересчитываем для каждого кластера центр\n", + " \n", + "Делаем это пока происходят изменения или пока не надоест" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Вероятностная модель" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Давайте предположим, что распределение точек в пространстве соответствует какой-то смеси гауссианов. Хотим найти параметры этих гауссианов и коэффициенты смеси.\n", + "\n", + "Тогда, у нас есть $k$ гауссианов с параметрами $(\\mu_i, \\sigma_i)$. Есть точки $x_i$ полученных в результате сэмплирования этого распределения. Хотим найти такие $(\\mu_i, \\sigma_i)$ и $\\overline{\\pi}$, чтобы правдоподобие было максимальным. То есть, хотим найти максимум выражения$$\n", + "\\prod_{i = 1}^n p(x | \\overline{\\mu}, \\overline{\\sigma}, \\overline{\\pi}) = \\prod_{i = 1}^n \\sum_{j = 1}^n \\pi_j \\frac{1}{\\sqrt{2\\pi \\sigma_j}}e^{-\\frac{(x_i-\\mu_j)^2}{2\\sigma_j^2}}$$\n", + "\n", + "Как раньше мы такое делали? Мы брали логарифм и оптимизировали его. Но тут у нас произведение сумм. Если мы возьмем логарифм, у нас получится сумма логарифмов сумм, что выглядит не так просто, как в случае с логистической регрессией." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Основная идея EM-алгоритма" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Давайте введем дополнительные переменные. Пусть \n", + "$z_{ij} = \\begin{cases} 1, &\\mbox{if } x_i \\texttt{ from cluster j} \\\\ \n", + "0, & \\mbox{otherwise }\\end{cases}$\n", + "\n", + "То есть, давайте предположим, что нам кто-то подсказал, в какой кластер должна попасть каждая точка. Посмотрим как теперь выглядит правдоподобие:\n", + "\n", + "$$p(X, Z | \\overline{\\mu}, \\overline{\\sigma}, \\overline{\\pi}) = \\prod_{i = 1}^n \\prod_{j = 1}^n \\left(\\frac{\\pi_j}{\\sqrt{2\\pi \\sigma_j}}e^{-\\frac{(x_i-\\mu_j)^2}{2\\sigma_j^2}}\\right)^{z_{ij}}$$\n", + "\n", + "Теперь в формуле нет суммирования, поэтому давайте возьмём логарифм и будем оптимизировать логарифм правдоподобия.\n", + "\n", + "Давайте также при взятии логарифма разделим все выражение на несколько независимых сумм\n", + "\n", + "$$\\ln p(X, Z | \\overline{\\mu}, \\overline{\\sigma}, \\overline{\\pi}) = \\sum_{j=0}^k \\left(\\ln \\pi_j \\sum_{i = 1}^n z_{ij}\\right) + \\sum_{j=0}^k \\left(\\frac{1}{2}\\frac{\\ln (2\\pi\\sigma_j)}{2\\sigma_j^2}\\sum_{i = 1}^n z_{ij} (x_i - \\mu_j)^2\\right)$$\n", + "\n", + "В таком виде уже проще оптимизировать. Видно, что коэфициенты смеси находятся сразу, а дальше нам нужно обучить $k$ гауссианов незавиcимо." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### EM-алгоритм" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "EM-алгоритм это итеративный алгоритм. На итерации $t$ есть $Z^{(t)} - $ вектор вероятностей, $Z_{ij}^{(t)} - $ вероятность того, что точка $x_i$ должна быть в кластере $j$ и $\\theta^{(t)} - $ параметры гауссианов и коэффициенты смеси. Каждая итерация состоит из двух шагов: \n", + "\n", + "* $\\texttt{E--Step (Expectation)}$ Оцениваем $Z^{(t+1)}$ через $\\theta^{(t)}$. На самой первой итерации считаем, что $z_{ij} = \\frac{1}{k}$\n", + "* $\\texttt{M--Step (Maximize)}$ Ищем оптимальное $\\theta_{t + 1}$, максимизирующее $p(X, Z^{(t + 1)} | \\theta^{(t + 1)})$\n", + "\n", + "\n", + "Выполняем итерации, пока не сойдется процесс или пока нам не надоест\n", + "\n", + "Теперь формулы\n", + "\n", + "**E-step**\n", + "\n", + "$$Z_{ij}^{(t + 1)} = \\frac{p(x_i | \\mu^{(t)}_j, \\sigma^{(t)}_j)}{\\sum_{l = 1}^k p(x_i | \\mu^{(t)}_l, \\sigma^{(t)}_l)}$$\n", + "\n", + "где $p(x_i | \\mu_j, \\sigma_j)\\, - $ плотность гауссиана, т.е. $p(x | \\mu, \\sigma) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}}e^{-\\frac{(x-\\mu)^2}{2\\sigma^2}}$\n", + "\n", + "**M-step**\n", + "\n", + "Вспомним формулу, которую мы оптимизируем:\n", + "\n", + "$$\\ln p(X, Z | \\overline{\\mu}, \\overline{\\sigma}, \\overline{\\pi}) = \\sum_{j=0}^k \\left(\\ln \\pi_j \\sum_{i = 1}^n z_{ij}\\right) + \\sum_{j=0}^k \\left(\\frac{1}{2}\\frac{\\ln (2\\pi\\sigma_j)}{2\\sigma_j^2}\\sum_{i = 1}^n z_{ij} (x_i - \\mu_j)^2\\right)$$\n", + "\n", + "* пересчитываем $\\overline\\pi$ вот так: $\\pi_j = \\frac{\\sum_{i = 1}^n Z^{(t + 1)}_{ij}}{n}$\n", + "\n", + "\n", + "* $\\mu^{(t)}_j = \\mathbb{E}Z^{(t + 1)}_{*j} x_*$, а $\\sigma^{(t)}_j = \\sqrt{\\mathbb{D}Z^{(t + 1)}_{*j} x_*}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Почему же EM-алгоритм работает" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Надо было максимизировать $p(X | \\theta)$, а мы ввели $Z$ и оптимизуем $p(X, Z | \\theta)$. Обоснуем наш выбор.\n", + "\n", + "EM-алгоритм строит последовательность $\\theta^{(t)}$, докажем, что $p(X|\\theta^{(t)})$ возрастает.\n", + "\n", + "Рассмотрим функцию $\\ln p(X|\\theta) - \\ln p(X|\\theta^{(t)})$. Нужно ее максимизировать. Преобразуем ее:\n", + "\n", + "$$\\ln p(X|\\theta) - \\ln p(X|\\theta^{(t)}) = \\\\\n", + " \\ln\\int p(X, Z|\\theta)dz - l^{(t)} = \\\\\n", + " \\ln\\int \\frac{p(X|\\theta, Z)p(Z | \\theta)}{p(Z|X, \\theta^{(t)})}p(Z|X, \\theta^{(t)}) dz - l^{(t)} = \\\\\n", + " \\left[\\texttt{Jensen's inequality: for convex } f \\texttt{ holds } \\int g(x)p(x) \\ge \\int f(g(x))p(x)\\right] \\ge \\\\\n", + " \\int \\ln\\frac{p(X|\\theta, Z)p(Z | \\theta)}{p(Z|X, \\theta^{(t)})}p(Z|X, \\theta^{(t)}) dz - l^{(t)} = \\\\\n", + " \\int \\ln\\frac{p(X|\\theta, Z)p(Z | \\theta)}{p(Z|X, \\theta^{(t)})p(X|\\theta^{(t)})}p(Z|X, \\theta^{(t)}) dz$$\n", + "\n", + "Обозначим через $L(\\theta, \\theta^{(t)}) = \\int \\ln\\frac{p(X|\\theta, Z)p(Z | \\theta)}{p(Z|X, \\theta^{(t)})p(X|\\theta^{(t)})}p(Z|X, \\theta^{(t)}) dz$, а через $l(\\theta) = \\ln p(X|\\theta)$\n", + "\n", + "Заметим, что:\n", + "* $l(\\theta) \\ge L(\\theta, \\theta^{(t)}) + l(\\theta^{(t)})$\n", + "* $L(\\theta^{(t)}, \\theta^{(t)}) = 0$\n", + "\n", + "Наша цель найти $\\texttt{argmax } l(\\theta)$, но $l(\\theta)$ сложно максимизируется. Давайте найдем максимум $L(\\theta, \\theta^{(t)})$ и присвоим $\\theta^{(t + 1)} = \\texttt{argmax } L(\\theta, \\theta^{(t)})$. Из того, что мы заметили, видно, что значение $l$ в новой точке увеличится, а значит мы приблизимся к точке максимума.\n", + "\n", + "Давайте оптимизировать $L(\\theta, \\theta^{(t)})$ по $\\theta$. Заметим, что знаменатель не зависит от $\\theta$, поэтому его откидываем. Получаем, что надо оптимизировать следующее выражение:\n", + "\n", + "$$\\int \\ln p(X, Z|\\theta^{(t)}) p(Z|X, \\theta^{(t)})$$\n", + "\n", + "Распишем логарифм произведения через сумму логарифмов. Получим \n", + "\n", + "$$ \\int \\left(\\sum_{i = 1}^n \\sum_{j = 1}^k z_{ij} \\ln (\\pi_j p(x_i | \\theta_j))\\right) p(Z|X, \\theta^{(t)})$$\n", + "\n", + "Давайте теперь суммы и $\\ln (\\pi_j p(x_i | \\theta_j))$ вынесем перед интеграл, получим\n", + "\n", + "$$ \\sum_{i = 1}^n \\sum_{j = 1}^k \\left(\\ln (\\pi_j p(x_i | \\theta_j)) \\int z_{ij} p(Z|X, \\theta^{(t)})\\right)$$\n", + "\n", + "А последним действием заметим, что под интегралом теперь находится $\\mathbb{E}_{Z|X, \\theta^{(t)}}z_{ij}$\n", + "\n", + "Вот мы и получили: вначале можно посчитать матожидание $z_{ij}$ по распределению $Z|X, \\theta^{(t)}$, потом подставить полученные $z_{ij}$ и обучить гауссианы" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Замечания" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* EM-алгоритм не факт, что найдет глобальный максимум. Вообще, на поверхности несколько точек максимумов (можно гауссианы переставлять местами)\n", + "* Не очень понятно, за сколько итераций алгоритм сойдется\n", + "* EM-алгоритм требует на вход ожидаемое число кластеров\n", + "* Можно модифицировать под обучение с учителем (например, если мы знаем про некоторые точки в каком кластере они должны лежать)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Код и картинки для EM-алгоритма" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "from collections import OrderedDict\n", + "from time import time\n", + "\n", + "import numpy as np\n", + "import scipy as sp\n", + "\n", + "from scipy.optimize import fmin_powell\n", + "from scipy import integrate\n", + "from scipy import linalg\n", + "\n", + "from sklearn.preprocessing import normalize\n", + "from sklearn import linear_model\n", + "from sklearn.utils.testing import ignore_warnings\n", + "from sklearn.exceptions import ConvergenceWarning\n", + "\n", + "np.set_printoptions(precision=4, suppress=True)\n", + "\n", + "from collections import Counter\n", + "\n", + "figsize = (15,8)\n", + "legend_fontsize = 16\n", + "\n", + "from matplotlib import rc\n", + "rc('font',**{'family':'sans-serif'})\n", + "rc('text', usetex=True)\n", + "rc('text.latex',preamble=r'\\usepackage[utf8]{inputenc}')\n", + "rc('text.latex',preamble=r'\\usepackage[russian]{babel}')\n", + "rc('axes', **{'titlesize': '16', 'labelsize': '16'})\n", + "rc('legend', **{'fontsize': '16'})\n", + "rc('figure', **{'dpi' : 300})" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def sample_mixture(N, pi, mu1, sigma1, mu2, sigma2):\n", + " z = np.array( np.random.rand(N) < pi, dtype=int)\n", + " res = np.zeros((N, 2))\n", + " res[np.where(z == 1)] = np.random.multivariate_normal(mu1, sigma1, np.sum(z))\n", + " res[np.where(z == 0)] = np.random.multivariate_normal(mu2, sigma2, N-np.sum(z))\n", + " return z, res\n", + "\n", + "def sample_two_classes(mu1, sigma1, mu2, sigma2, pi=0.5, N=200, Ntest=None):\n", + " z, x = sample_mixture(N, pi, mu1, sigma1, mu2, sigma2)\n", + " if Ntest is None:\n", + " return z, x\n", + " else:\n", + " test_z, test_x = sample_mixture(Ntest, pi, mu1, sigma1, mu2, sigma2)\n", + " return z, x, test_z, test_x\n", + "\n", + "def plot_points(ax, x, z, mus=None, mu1=None, mu2=None, sigmas=None, points_alpha=1.0, colors=['r', 'b', 'g', 'magenta', 'grey', 'purple', 'darkgreen', 'orange', 'black']):\n", + "# print(set(z))\n", + " for i in set(z):\n", + " ax.scatter(x[np.where(z==i), 0], x[np.where(z==i), 1], marker='.', color=colors[i % 9], alpha=points_alpha)\n", + " if sigmas is not None:\n", + " plot_ellipse(ax, mus[i], sigmas[i], colors[i % 9])\n", + " if mus is not None:\n", + " for i in range(mus.shape[0]):\n", + " ax.scatter([mus[i, 0]], [mus[i, 1]], marker='*', s=200, color=colors[i % 9])\n", + " if mu1 is not None:\n", + " for i in range(mu1.shape[0]):\n", + " ax.scatter([mu1[i, 0]], [mu1[i, 1]], marker='*', s=200, color=colors[0])\n", + " if mu2 is not None:\n", + " for i in range(mu2.shape[0]):\n", + " ax.scatter([mu2[i, 0]], [mu2[i, 1]], marker='*', s=200, color=colors[1])\n", + "\n", + "from matplotlib import colors\n", + "cmap = colors.LinearSegmentedColormap(\n", + " 'red_blue_classes',\n", + " {'red': [(0, 1, 1), (1, 0.7, 0.7)],\n", + " 'green': [(0, 0.7, 0.7), (1, 0.7, 0.7)],\n", + " 'blue': [(0, 0.7, 0.7), (1, 1, 1)]})\n", + "\n", + "def plot_ellipse(ax, mu, sigma, color):\n", + " v, w = sp.linalg.eigh(sigma)\n", + " u = w[0] / sp.linalg.norm(w[0])\n", + " angle = np.arctan(u[1] / u[0])\n", + " angle = 180 * angle / np.pi\n", + " ell = mpl.patches.Ellipse(mu, 2 * v[0] ** 0.5, 2 * v[1] ** 0.5,\n", + " 180 + angle, facecolor=color,\n", + " edgecolor='black', linewidth=2)\n", + " ell.set_clip_box(ax.bbox)\n", + " ell.set_alpha(0.2)\n", + " ax.add_artist(ell)\n", + " ax.scatter(mu[0], mu[1], marker='+', color=color, s=100)\n", + "\n", + "def get_meshgrid(nx=200, ny=200):\n", + " x_min, x_max = plt.xlim()\n", + " y_min, y_max = plt.ylim()\n", + " return np.meshgrid(np.linspace(x_min, x_max, nx), np.linspace(y_min, y_max, ny))\n", + "\n", + "def plot_colormesh(ax, model):\n", + " xx, yy = get_meshgrid()\n", + " Z = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])\n", + " Z = Z[:, 1].reshape(xx.shape)\n", + " plt.pcolormesh(xx, yy, Z, cmap=cmap,\n", + " norm=colors.Normalize(0., 1.), zorder=0)\n", + " plt.contour(xx, yy, Z, [0.5], linewidths=2., colors='white')\n", + "\n", + "def plot_colormesh_svm(ax, model):\n", + " xx, yy = get_meshgrid()\n", + " Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n", + " ax.pcolormesh(xx, yy, Z, cmap=cmap,\n", + " norm=colors.Normalize(0., 1.), zorder=0)\n", + " ax.contour(xx, yy, Z, [-1, 0, 1], linewidths=2., colors='white', linestyles=['--', '-', '--'])\n", + "\n", + "def plot_svm_decision(ax, model, xx, yy):\n", + " Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n", + " ax.contour(xx, yy, Z, [0], linewidths=.5, colors='black', linestyles=['-'])\n", + "\n", + "def plot_svm_decisions(ax, models):\n", + " xx, yy = get_meshgrid()\n", + " for model in models:\n", + " plot_svm_decision(ax, model, xx, yy)\n", + " \n", + "def sample_rings(rad_inner, rad_outer, rad_inner2, rad_outer2, pi=0.5, N=200, Ntest=None):\n", + " z = np.array( np.random.rand(N) < pi, dtype=int)\n", + " rs = ( rad_inner + (rad_inner - rad_outer) * np.random.rand(np.sum(z)) )\n", + " thetas = 2 * np.pi * np.random.rand(np.sum(z))\n", + " rs2 = ( rad_inner2 + (rad_inner2 - rad_outer2) * np.random.rand(N - np.sum(z)) )\n", + " thetas2 = 2 * np.pi * np.random.rand(N - np.sum(z))\n", + " \n", + " res = np.zeros((N, 2))\n", + " res[np.where(z == 1)] = np.array([ rs * np.cos(thetas), rs * np.sin(thetas) ]).T\n", + " res[np.where(z == 0)] = np.array([ rs2 * np.cos(thetas2), rs2 * np.sin(thetas2) ]).T\n", + " return z, res\n", + "\n", + "def sample_mixture(N, pi, mu1, sigma1, mu2, sigma2):\n", + " z = np.array( np.random.rand(N) < pi, dtype=int)\n", + " res = np.zeros((N, 2))\n", + " res[np.where(z == 1)] = np.random.multivariate_normal(mu1, sigma1, np.sum(z))\n", + " res[np.where(z == 0)] = np.random.multivariate_normal(mu2, sigma2, N-np.sum(z))\n", + " return z, res\n", + "\n", + "def sample_mixtures(mu0=np.array([ [-1,-1], [1,1] ]), sigma0=2, k=5, pi=0.5, df=4, N=200, Ntest=None):\n", + " z = np.array( np.random.rand(N) < pi, dtype=int)\n", + " res = np.zeros((N, 2))\n", + " mus, sigmas = [], []\n", + " for i, n in zip(range(2), [N-np.sum(z), np.sum(z)]):\n", + " mus.append( np.random.multivariate_normal(mu0[i], sigma0 * np.identity(2), k) )\n", + " sigmas.append( sp.stats.invwishart.rvs(df, np.identity(2), size=k) )\n", + " mixture_ind = np.random.randint(k, size=n)\n", + " cur_res = np.zeros((n, 2))\n", + " for j in range(k):\n", + " cur_indices = np.where(mixture_ind == j)[0]\n", + " cur_res[cur_indices] = np.random.multivariate_normal(mus[-1][j], sigmas[-1][j], len(cur_indices))\n", + " res[np.where(z == i)] = cur_res\n", + " return z, res, mus, sigmas\n", + "\n", + "def sample_oneclass_mixture(mu0=np.array([0, 0]), sigma0=2, k=5, pi=None, df=4, N=200, Ntest=None):\n", + " mus = np.random.multivariate_normal(mu0, sigma0 * np.identity(2), k)\n", + " sigmas = sp.stats.invwishart.rvs(df, np.identity(2), size=k)\n", + " mixture_ind = np.random.randint(k, size=N)\n", + " res = np.zeros((N, 2))\n", + " for j in range(k):\n", + " cur_indices = np.where(mixture_ind == j)[0]\n", + " res[cur_indices] = np.random.multivariate_normal(mus[j], sigmas[j], len(cur_indices))\n", + " return np.eye(k)[mixture_ind], res, mus, sigmas\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## EM-алгоритм для кластеризации" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(4)\n", + "\n", + "k = 4\n", + "z, x, true_mus, true_sigmas = sample_oneclass_mixture(k=k, sigma0=2, df=20, N=300)\n", + "\n", + "fig = plt.figure(figsize=(15,8))\n", + "ax = fig.add_subplot(111)\n", + "plot_points(ax, x, np.argmax(z, axis=1), mus=true_mus, sigmas=2 * true_sigmas, points_alpha=.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def e_step(xs, pis, mus, sigmas):\n", + " k = mus.shape[0]\n", + " z = np.array([ pis[i] * sp.stats.multivariate_normal.pdf(xs, mean=mus[i], cov=sigmas[i]) for i in range(k) ])\n", + " ## здесь z_{nk} = p(C_k)p(x_n|C_k)\n", + " z = np.divide( z, np.sum(z, axis=0) ).T\n", + " ## z_{nk} = p(C_k|x_n)\n", + " return z\n", + "\n", + "def m_step(xs, z):\n", + " k = z.shape[1]\n", + " pis = np.sum(z, axis=0) / np.sum(z)\n", + " mus = np.array([np.average(xs, weights=z[:,i], axis=0) for i in range(k)])\n", + " sigmas = np.array([np.cov(xs.T, aweights=z[:,i]) for i in range(k)])\n", + " return pis, mus, sigmas\n", + "\n", + "def loglikelihood(xs, pis, mus, sigmas):\n", + " k = mus.shape[0]\n", + " return np.sum(np.log(np.sum(np.array([ pis[i] * sp.stats.multivariate_normal.pdf(xs, mean=mus[i], cov=sigmas[i]) for i in range(k) ]), axis=0)))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "seed = 11\n", + "np.random.seed(seed)\n", + "\n", + "k = 4\n", + "mus = x[ np.random.choice(x.shape[0], size=k, replace=False), : ]\n", + "sigmas = np.array( [ np.identity(2) for _ in range(k) ] )\n", + "pis = (1./k) * np.ones(k)\n", + "z = e_step( x, pis, mus, sigmas)\n", + "\n", + "fig = plt.figure(figsize=(15,8))\n", + "ax = fig.add_subplot(111)\n", + "plot_points(ax, x, np.argmax(z, axis=1), mus=mus, sigmas=2 * sigmas, points_alpha=.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "import ipywidgets as widgets\n", + "from IPython.display import display\n", + "\n", + "\n", + "def step_slice(lst, step):\n", + " return lst[step]\n", + "\n", + "\n", + "def animate_list(lst, play=False, interval=200):\n", + " slider = widgets.IntSlider(min=0, max=len(lst) - 1, step=1, value=0)\n", + " if play:\n", + " play_widjet = widgets.Play(interval=interval)\n", + " widgets.jslink((play_widjet, 'value'), (slider, 'value'))\n", + " display(play_widjet)\n", + " # slider = widgets.Box([play_widject, slider])\n", + " return interact(step_slice,\n", + " lst=fixed(lst),\n", + " step=slider)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Логарифм правдоподобия на итерации 000: -432.902138\n", + "Логарифм правдоподобия на итерации 001: -377.488388\n", + "Логарифм правдоподобия на итерации 002: -373.640810\n", + "Логарифм правдоподобия на итерации 003: -368.536145\n", + "Логарифм правдоподобия на итерации 004: -363.650049\n", + "Логарифм правдоподобия на итерации 005: -360.106778\n", + "Логарифм правдоподобия на итерации 006: -356.984854\n", + "Логарифм правдоподобия на итерации 007: -353.546405\n", + "Логарифм правдоподобия на итерации 008: -349.581989\n", + "Логарифм правдоподобия на итерации 009: -344.953468\n", + "Логарифм правдоподобия на итерации 010: -340.161394\n", + "Логарифм правдоподобия на итерации 011: -336.892355\n", + "Логарифм правдоподобия на итерации 012: -335.515215\n", + "Логарифм правдоподобия на итерации 013: -335.014237\n", + "Логарифм правдоподобия на итерации 014: -334.807233\n", + "Логарифм правдоподобия на итерации 015: -334.695509\n", + "Логарифм правдоподобия на итерации 016: -334.615263\n", + "Логарифм правдоподобия на итерации 017: -334.545694\n", + "Логарифм правдоподобия на итерации 018: -334.479683\n", + "Логарифм правдоподобия на итерации 019: -334.414463\n", + "Логарифм правдоподобия на итерации 020: -334.348664\n", + "Логарифм правдоподобия на итерации 021: -334.281378\n", + "Логарифм правдоподобия на итерации 022: -334.211850\n", + "Логарифм правдоподобия на итерации 023: -334.139370\n", + "Логарифм правдоподобия на итерации 024: -334.063233\n", + "Логарифм правдоподобия на итерации 025: -333.982727\n", + "Логарифм правдоподобия на итерации 026: -333.897129\n", + "Логарифм правдоподобия на итерации 027: -333.805723\n", + "Логарифм правдоподобия на итерации 028: -333.707822\n", + "Логарифм правдоподобия на итерации 029: -333.602810\n", + "Логарифм правдоподобия на итерации 030: -333.490199\n", + "Логарифм правдоподобия на итерации 031: -333.369704\n", + "Логарифм правдоподобия на итерации 032: -333.241314\n", + "Логарифм правдоподобия на итерации 033: -333.105368\n", + "Логарифм правдоподобия на итерации 034: -332.962589\n", + "Логарифм правдоподобия на итерации 035: -332.814064\n", + "Логарифм правдоподобия на итерации 036: -332.661135\n", + "Логарифм правдоподобия на итерации 037: -332.505197\n", + "Логарифм правдоподобия на итерации 038: -332.347432\n", + "Логарифм правдоподобия на итерации 039: -332.188532\n", + "Логарифм правдоподобия на итерации 040: -332.028498\n", + "Логарифм правдоподобия на итерации 041: -331.866558\n", + "Логарифм правдоподобия на итерации 042: -331.701264\n", + "Логарифм правдоподобия на итерации 043: -331.530704\n", + "Логарифм правдоподобия на итерации 044: -331.352821\n", + "Логарифм правдоподобия на итерации 045: -331.165761\n", + "Логарифм правдоподобия на итерации 046: -330.968230\n", + "Логарифм правдоподобия на итерации 047: -330.759834\n", + "Логарифм правдоподобия на итерации 048: -330.541376\n", + "Логарифм правдоподобия на итерации 049: -330.315071\n", + "Логарифм правдоподобия на итерации 050: -330.084604\n", + "Логарифм правдоподобия на итерации 051: -329.854933\n", + "Логарифм правдоподобия на итерации 052: -329.631798\n", + "Логарифм правдоподобия на итерации 053: -329.420928\n", + "Логарифм правдоподобия на итерации 054: -329.227163\n", + "Логарифм правдоподобия на итерации 055: -329.053721\n", + "Логарифм правдоподобия на итерации 056: -328.901887\n", + "Логарифм правдоподобия на итерации 057: -328.771183\n", + "Логарифм правдоподобия на итерации 058: -328.659875\n", + "Логарифм правдоподобия на итерации 059: -328.565583\n", + "Логарифм правдоподобия на итерации 060: -328.485774\n", + "Логарифм правдоподобия на итерации 061: -328.418082\n", + "Логарифм правдоподобия на итерации 062: -328.360448\n", + "Логарифм правдоподобия на итерации 063: -328.311152\n", + "Логарифм правдоподобия на итерации 064: -328.268784\n", + "Логарифм правдоподобия на итерации 065: -328.232198\n", + "Логарифм правдоподобия на итерации 066: -328.200465\n", + "Логарифм правдоподобия на итерации 067: -328.172828\n", + "Логарифм правдоподобия на итерации 068: -328.148666\n", + "Логарифм правдоподобия на итерации 069: -328.127468\n", + "Логарифм правдоподобия на итерации 070: -328.108811\n", + "Логарифм правдоподобия на итерации 071: -328.092342\n", + "Логарифм правдоподобия на итерации 072: -328.077763\n", + "Логарифм правдоподобия на итерации 073: -328.064826\n", + "Логарифм правдоподобия на итерации 074: -328.053319\n", + "Логарифм правдоподобия на итерации 075: -328.043061\n", + "Логарифм правдоподобия на итерации 076: -328.033898\n", + "После 76 итераций правдоподобие = -328.033898\n" + ] + } + ], + "source": [ + "## EM-алгоритм\n", + "np.random.seed(seed)\n", + "\n", + "k = 4\n", + "mus = x[ np.random.choice(x.shape[0], size=k, replace=False), : ]\n", + "sigmas = np.array( [ np.identity(2) for _ in range(k) ] )\n", + "pis = (1./k) * np.ones(k)\n", + "z = e_step( x, pis, mus, sigmas)\n", + "\n", + "old_logl, new_logl = -np.inf, -np.inf\n", + "plots = []\n", + "for iIter in range(5000):\n", + " old_logl = new_logl\n", + " z = e_step( x, pis, mus, sigmas)\n", + " # print(z)\n", + " new_pis, new_mus, new_sigmas = m_step(x, z)\n", + " fig = plt.figure(figsize=(15,8))\n", + " ax = fig.add_subplot(111)\n", + " plot_points(ax, x, np.argmax(z, axis=1), mus=new_mus, sigmas=2 * new_sigmas, points_alpha=.5)\n", + " plt.close(fig) # to show using interactive\n", + " plots.append(fig) # to show using interactive\n", + "# plt.show() # to show without interactive\n", + " pis, mus, sigmas = new_pis, new_mus, new_sigmas\n", + " new_logl = loglikelihood(x, pis, mus, sigmas)\n", + " print(\"Логарифм правдоподобия на итерации %03d: %.6f\" % (iIter, new_logl) )\n", + " if np.abs(new_logl - old_logl) < 0.01:\n", + " break\n", + "\n", + "print(\"После %d итераций правдоподобие = %.6f\" % (iIter, new_logl) )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "77\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4bcf5dc1787149cc82ac5dd27a57b439", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Play(value=0, interval=2000)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0518f891da4446e5943a4388a15e167e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='step', max=76), Output()), _dom_classes=('widget-interac…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(len(plots))\n", + "animate_list(plots, play=True, interval=2000)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.1973 0.2333 0.3348 0.2345]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print(pis)\n", + "fig = plt.figure(figsize=(15,8))\n", + "ax = fig.add_subplot(111)\n", + "plot_points(ax, x, np.argmax(z, axis=1), mus=new_mus, sigmas=2 * new_sigmas, points_alpha=.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(4)\n", + "\n", + "k = 4\n", + "z, x, true_mus, true_sigmas = sample_oneclass_mixture(k=k, sigma0=2, df=20, N=300)\n", + "\n", + "fig = plt.figure(figsize=(15,8))\n", + "ax = fig.add_subplot(111)\n", + "plot_points(ax, x, np.argmax(z, axis=1), mus=true_mus, sigmas=2 * true_sigmas, points_alpha=.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Конец" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}