_c7e6faae82e5eb22b953647eb1fa5ca3_vector_operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `NumPy`: векторы и операции над ними\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом ноутбуке нам понадобятся библиотека `NumPy`. Для удобства импортируем ее под более коротким именем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Создание векторов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самый простой способ создать вектор в `NumPy` — задать его явно с помощью __`numpy.array(list, dtype=None, ...)`__.\n",
    "\n",
    "Параметр __`list`__ задает итерируемый объект, из которого можно создать вектор. Например, в качестве этого параметра можно задать список чисел. Параметр __`dtype`__ задает тип значений вектора, например, __`float`__ — для вещественных значений и __`int`__ — для целочисленных. Если этот параметр не задан, то тип данных будет определен из типа элементов первого аргумента. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор:\n",
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "print 'Вектор:\\n', a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вещественный вектор:\n",
      "[ 1.  2.  3.  4.  5.]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([1, 2, 3, 4, 5], dtype=float)\n",
    "print 'Вещественный вектор:\\n', b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Булевский вектор:\n",
      "[ True False  True]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([True, False, True], dtype=bool)\n",
    "print 'Булевский вектор:\\n', c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тип значений вектора можно узнать с помощью __`numpy.ndarray.dtype`__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Тип булевского вектора:\n",
      "bool\n"
     ]
    }
   ],
   "source": [
    "print 'Тип булевского вектора:\\n', c.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Другим способом задания вектора является функция __`numpy.arange(([start, ]stop, [step, ]...)`__, которая задает последовательность чисел заданного типа из промежутка __[`start`, `stop`)__ через шаг __`step`__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор чисел от 10 до 20 с шагом 2:\n",
      "[10 12 14 16 18]\n"
     ]
    }
   ],
   "source": [
    "d = np.arange(start=10, stop=20, step=2) # последнее значение не включается!\n",
    "print 'Вектор чисел от 10 до 20 с шагом 2:\\n', d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вещественный вектор чисел от 0 до 1 с шагом 0.3:\n",
      "[ 0.   0.3  0.6  0.9]\n"
     ]
    }
   ],
   "source": [
    "f = np.arange(start=0, stop=1, step=0.3, dtype=float)\n",
    "print 'Вещественный вектор чисел от 0 до 1 с шагом 0.3:\\n', f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По сути вектор в `NumPy` является одномерным массивом, что соответствует интуитивному определению вектора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print c.ndim # количество размерностей"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "print c.shape # shape фактически задает длину вектора "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ _вектор _и одномерный массив тождественные понятия в `NumPy`. Помимо этого, также существуют понятия _вектор-столбец_ и _вектор-строка_, которые, несмотря на то что математически задают один и тот же объект, являются двумерными массивами и имеют другое значение поля __`shape`__ (в этом случае поле состоит из двух чисел, одно из которых равно единице). Эти тонкости будут рассмотрены в следующем уроке."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как создавать векторы в `NumPy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Операции над векторами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Векторы в `NumPy` можно складывать, вычитать, умножать на число и умножать на другой вектор (покоординатно):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [1 2 3]\n",
      "Вектор b: [6 5 4]\n",
      "Число k: 2\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([6, 5, 4])\n",
    "k = 2\n",
    "\n",
    "print 'Вектор a:', a\n",
    "print 'Вектор b:', b\n",
    "print 'Число k:', k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сумма a и b:\n",
      "[7 7 7]\n"
     ]
    }
   ],
   "source": [
    "print 'Сумма a и b:\\n', a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Разность a и b:\n",
      "[-5 -3 -1]\n"
     ]
    }
   ],
   "source": [
    "print 'Разность a и b:\\n', a - b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Покоординатное умножение a и b:\n",
      "[ 6 10 12]\n"
     ]
    }
   ],
   "source": [
    "print 'Покоординатное умножение a и b:\\n', a * b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Умножение вектора на число (осуществляется покоординатно):\n",
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "print 'Умножение вектора на число (осуществляется покоординатно):\\n', k * a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Нормы векторов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вспомним некоторые нормы, которые можно ввести в пространстве $\\mathbb{R}^{n}$, и рассмотрим, с помощью каких библиотек и функций их можно вычислять в `NumPy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### p-норма"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "p-норма (норма Гёльдера) для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n",
    "\n",
    "$$\n",
    "\\left\\Vert x \\right\\Vert_{p} = \\left( \\sum_{i=1}^n \\left| x_{i} \\right|^{p} \\right)^{1 / p},~p \\geq 1.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В частных случаях при:\n",
    "* $p = 1$ получаем $\\ell_{1}$ норму\n",
    "* $p = 2$ получаем $\\ell_{2}$ норму"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее нам понабится модуль `numpy.linalg`, реализующий некоторые приложения линейной алгебры. Для вычисления различных норм мы используем функцию __`numpy.linalg.norm(x, ord=None, ...)`__, где __`x`__ — исходный вектор, __`ord`__ — параметр, определяющий норму (мы рассмотрим два варианта его значений — 1 и 2). Импортируем эту функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy.linalg import norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\ell_{1}$ норма"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\ell_{1}$ норма \n",
    "(также известная как [манхэттенское расстояние](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2))\n",
    "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n",
    "\n",
    "$$\n",
    " \\left\\Vert x \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} \\right|.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ей в функции __`numpy.linalg.norm(x, ord=None, ...)`__ соответствует параметр __`ord=1`__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 1  2 -3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "print 'Вектор a:', a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 норма вектора a:\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print 'L1 норма вектора a:\\n', norm(a, ord=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\ell_{2}$ норма"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\ell_{2}$ норма (также известная как евклидова норма)\n",
    "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n",
    "\n",
    "$$\n",
    " \\left\\Vert x \\right\\Vert_{2} = \\sqrt{\\sum_{i=1}^n \\left( x_{i} \\right)^2}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ей в функции __`numpy.linalg.norm(x, ord=None, ...)`__ соответствует параметр __`ord=2`__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 1  2 -3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "print 'Вектор a:', a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L2 норма вектора a:\n",
      "3.74165738677\n"
     ]
    }
   ],
   "source": [
    "print 'L2 норма вектора a:\\n', norm(a, ord=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, какие еще нормы (в том числе матричные) можно вычислить, см. [документацию](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.norm.html). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Расстояния между векторами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для двух векторов $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ и $y = (y_{1}, \\dots, y_{n}) \\in \\mathbb{R}^{n}$ $\\ell_{1}$ и $\\ell_{2}$ раccтояния вычисляются по следующим формулам соответственно:\n",
    "\n",
    "$$\n",
    " \\rho_{1}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} - y_{i} \\right|\n",
    "$$\n",
    "\n",
    "$$\n",
    " \\rho_{2}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{2} = \n",
    " \\sqrt{\\sum_{i=1}^n \\left( x_{i} - y_{i} \\right)^2}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 1  2 -3]\n",
      "Вектор b: [-4  3  8]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "b = np.array([-4, 3, 8])\n",
    "print 'Вектор a:', a\n",
    "print 'Вектор b:', b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 расстояние между векторами a и b:\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "print 'L1 расстояние между векторами a и b:\\n', norm(a - b, ord=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L2 расстояние между векторами a и b:\n",
      "12.124355653\n"
     ]
    }
   ],
   "source": [
    "print 'L2 расстояние между векторами a и b:\\n', norm(a - b, ord=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также расстояние между векторами можно посчитать с помощью функции __`scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)`__ из модуля `SciPy`, предназначенного для выполнения научных и инженерных расчётов. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy.spatial.distance import cdist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__`scipy.spatial.distance.cdist(...)`__ требует, чтобы размерность __`XA`__ и __`XB`__ была как минимум двумерная. По этой причине для использования этой функции необходимо преобразовать _векторы_, которые мы рассматриваем в этом ноутбуке, к _вектор-строкам_ с помощью способов, которые мы рассмотрим ниже. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Параметры __`XA, XB`__ — исходные вектор-строки, а __`metric`__ и __`p`__ задают метрику расстояния\n",
    "(более подробно о том, какие метрики можно использовать, см. [документацию](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.distance.cdist.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Первый способ из _вектора_ сделать _веткор-строку (вектор-столбец)_ — это использовать _метод_ __`array.reshape(shape)`__, где параметр __`shape`__ задает размерность вектора (кортеж чисел)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 6  3 -5]\n",
      "Его размерность: (3,)\n",
      "Вектор b: [-1  0  7]\n",
      "Его размерность: (3,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([6, 3, -5])\n",
    "b = np.array([-1, 0, 7])\n",
    "print 'Вектор a:', a\n",
    "print 'Его размерность:', a.shape\n",
    "print 'Вектор b:', b\n",
    "print 'Его размерность:', b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "После применения метода reshape:\n",
      "\n",
      "Вектор-строка a: [[ 6  3 -5]]\n",
      "Его размерность: (1, 3)\n",
      "Вектор-строка b: [[-1  0  7]]\n",
      "Его размерность: (1, 3)\n"
     ]
    }
   ],
   "source": [
    "a = a.reshape((1, 3))\n",
    "b = b.reshape((1, 3))\n",
    "print 'После применения метода reshape:\\n'\n",
    "print 'Вектор-строка a:', a\n",
    "print 'Его размерность:', a.shape\n",
    "print 'Вектор-строка b:', b\n",
    "print 'Его размерность:', b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Манхэттенское расстояние между a и b (через cdist): [[ 22.]]\n"
     ]
    }
   ],
   "source": [
    "print 'Манхэттенское расстояние между a и b (через cdist):', cdist(a, b, metric='cityblock')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что после применения этого метода размерность полученных вектор-строк будет равна __`shape`__. Следующий метод позволяет сделать такое же преобразование, но не изменяет размерность исходного вектора.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `NumPy` к размерностям объектов можно добавлять фиктивные оси с помощью __`np.newaxis`__. Для того, чтобы понять, как это сделать, рассмотрим пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор d: [  3   0   8   9 -10]\n",
      "Его размерность: (5,)\n"
     ]
    }
   ],
   "source": [
    "d = np.array([3, 0, 8, 9, -10])\n",
    "print 'Вектор d:', d\n",
    "print 'Его размерность:', d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор d с newaxis --> вектор-строка:\n",
      "[[  3   0   8   9 -10]]\n",
      "Полученная размерность: (1, 5)\n",
      "Вектор d с newaxis --> вектор-столбец:\n",
      "[[  3]\n",
      " [  0]\n",
      " [  8]\n",
      " [  9]\n",
      " [-10]]\n",
      "Полученная размерность: (5, 1)\n"
     ]
    }
   ],
   "source": [
    "print 'Вектор d с newaxis --> вектор-строка:\\n', d[np.newaxis, :]\n",
    "print 'Полученная размерность:', d[np.newaxis, :].shape\n",
    "\n",
    "print 'Вектор d с newaxis --> вектор-столбец:\\n', d[:, np.newaxis]\n",
    "print 'Полученная размерность:', d[:, np.newaxis].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Важно, что __`np.newaxis`__ добавляет к размерности ось, длина которой равна 1 (это и логично, так как количество элементов должно сохраняться). Таким образом, надо вставлять новую ось там, где нужна единица в размерности. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь посчитаем расстояния с помощью __`scipy.spatial.distance.cdist(...)`__, используя __`np.newaxis`__ для преобразования векторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Евклидово расстояние между a и b (через cdist): [[ 14.2126704]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([6, 3, -5])\n",
    "b = np.array([-1, 0, 7])\n",
    "print 'Евклидово расстояние между a и b (через cdist):', cdist(a[np.newaxis, :], \n",
    "                                                               b[np.newaxis, :], \n",
    "                                                               metric='euclidean')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта функция также позволяет вычислять попарные расстояния между множествами векторов. Например, пусть у нас имеется матрица размера $m_{A} \\times n$. Мы можем рассматривать ее как описание некоторых $m_{A}$ наблюдений в $n$-мерном пространстве. Пусть также имеется еще одна аналогичная матрица размера $m_{B} \\times n$, где  $m_{B}$ векторов в том же $n$-мерном пространстве. Часто необходимо посчитать попарные расстояния между векторами первого и второго множеств. В этом случае можно пользоваться функцией __`scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)`__, где в качестве __`XA, XB`__ необходимо передать две описанные матрицы. Функция возаращает матрицу попарных расстояний размера $m_{A} \\times m_{B}$, где элемент матрицы на $[i, j]$-ой позиции равен расстоянию между $i$-тым вектором первого множества и $j$-ым вектором второго множества. \n",
    "\n",
    "В данном случае эта функция предподчительнее __`numpy.linalg.norm(...)`__, так как она вычисляет попарные расстояния быстрее и эффективнее. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Скалярное произведение и угол между векторами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 0  5 -1]\n",
      "Вектор b: [-4  9  3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([0, 5, -1])\n",
    "b = np.array([-4, 9, 3])\n",
    "print 'Вектор a:', a\n",
    "print 'Вектор b:', b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скалярное произведение в пространстве $\\mathbb{R}^{n}$ для двух векторов $x = (x_{1}, \\dots, x_{n})$ и $y = (y_{1}, \\dots, y_{n})$ определяется как:\n",
    "\n",
    "$$\n",
    "\\langle x, y \\rangle = \\sum_{i=1}^n x_{i} y_{i}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скалярное произведение двух векторов можно вычислять помощью функции __`numpy.dot(a, b, ...)`__ или _метода_ __`vec1.dot(vec2)`__, где __`vec1`__ и __`vec2`__ — исходные векторы. Также эти функции подходят для матричного умножения, о котором речь пойдет в следующем уроке. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Скалярное произведение a и b (через функцию): 42\n"
     ]
    }
   ],
   "source": [
    "print 'Скалярное произведение a и b (через функцию):', np.dot(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Скалярное произведение a и b (через метод): 42\n"
     ]
    }
   ],
   "source": [
    "print 'Скалярное произведение a и b (через метод):', a.dot(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Длиной вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ называется квадратный корень из скалярного произведения, то есть длина равна евклидовой норме вектора:\n",
    "\n",
    "$$\n",
    "\\left| x \\right| = \\sqrt{\\langle x, x \\rangle} = \\sqrt{\\sum_{i=1}^n x_{i}^2} =  \\left\\Vert x \\right\\Vert_{2}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь, когда мы знаем расстояние между двумя ненулевыми векторами и их длины, мы можем вычислить угол между ними через скалярное произведение:\n",
    "\n",
    "$$\n",
    "\\langle x, y \\rangle = \\left| x \\right| | y | \\cos(\\alpha)\n",
    "\\implies \\cos(\\alpha) = \\frac{\\langle x, y \\rangle}{\\left| x \\right| | y |},\n",
    "$$\n",
    "\n",
    "где $\\alpha \\in [0, \\pi]$ — угол между векторами $x$ и $y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Косинус угла между a и b: 0.800036283647\n",
      "Сам угол: 0.643440633609\n"
     ]
    }
   ],
   "source": [
    "cos_angle = np.dot(a, b) / norm(a) / norm(b)\n",
    "print 'Косинус угла между a и b:', cos_angle\n",
    "print 'Сам угол:', np.arccos(cos_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как вычислять скалярное произведение в `NumPy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html#matrix-and-vector-products)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}