chainer08numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "chainer08numpy.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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.7.2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kalz2q/mycolabnotebooks/blob/master/chainer08numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3-ewqmV8hszX"
      },
      "source": [
        "# NumPy 入門\n",
        "\n",
        "本章では、Python で数値計算を高速に行うためのライブラリ（[注釈1](#note1)）である NumPy の使い方を学びます。\n",
        "本章の目標は、[単回帰分析と重回帰分析](https://tutorials.chainer.org/ja/07_Regression_Analysis.html)の章で学んだ重回帰分析を行うアルゴリズムを**NumPy を用いて実装すること**です。\n",
        "\n",
        "NumPy による**多次元配列（multidimensional array）**の扱い方を知ることは、他の様々なライブラリを利用する際に役立ちます。\n",
        "例えば、様々な機械学習手法を統一的なインターフェースで利用できる **scikit-learn** や、ニューラルネットワークの記述・学習を行うためのフレームワークである **Chainer** は、NumPy に慣れておくことでとても使いやすくなります。\n",
        "\n",
        "それでは、まず NumPy の基礎的な使用方法を説明します。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iPmvXIQThszZ"
      },
      "source": [
        "## NumPy を使う準備\n",
        "\n",
        "NumPy は Google Colaboratory（以下 Colab）上のノートブックにはデフォルトでインストールされているため、ここではインストールの方法は説明しません。自分のコンピュータに NumPy をインストールしたい場合は、こちらを参照してください。：[Installing packages](https://scipy.org/install.html)\n",
        "\n",
        "Colab 上ではインストール作業は必要ないものの、ノートブックを開いた時点ではまだ `numpy` モジュールが読み込まれていません。\n",
        "ライブラリの機能を利用するには、そのライブラリが提供するモジュールを読み込む必要があります。\n",
        "\n",
        "例えば `A` というモジュールを読み込みたいとき、一番シンプルな記述方法は `import A` です。\n",
        "ただ、もし `A` というモジュール名が長い場合は、`import A as B` のようにして別名を付けることができます。\n",
        "`as` を使って別名が与えられると、以降そのモジュールはその別名を用いて利用することができます。\n",
        "`import A as B` と書くと、`A` というモジュールは `B` という名前で利用することができます。\n",
        "これは Python の機能なので NumPy 以外のモジュールを読み込みたい場合にも使用可能です。\n",
        "\n",
        "慣習的に、`numpy` にはしばしば `np` という別名が与えられます。\n",
        "コード中で頻繁に使用するモジュールには、短い別名をつけて定義することがよく行われます。\n",
        "\n",
        "それでは、`numpy` を `np` という名前で `import` してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGm0nN_vuWfY"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SB5_Yx1qXAcN"
      },
      "source": [
        "## 多次元配列を定義する\n",
        "\n",
        "ベクトル・行列・テンソルなどは、プログラミング上は多次元配列により表現でき、NumPy では ndarray というクラスで多次元配列を表現します（[注釈2](#note2)）。早速、これを用いてベクトルを定義してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "HTartJBpvinm",
        "outputId": "0731ea56-3ac2-4ec5-c073-69a029d6d2c3"
      },
      "source": [
        "# ベクトルの定義\n",
        "a = np.array([1, 2, 3])\n",
        "\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LCbcrkX6hszo"
      },
      "source": [
        "このように、Python リスト `[1, 2, 3]` を `np.array()` に渡すことで、$[1, 2, 3]$ というベクトルを表す ndarray オブジェクトを作ることができます。\n",
        "ndarray オブジェクトは `shape` という**属性 （attribute）** を持っており、その多次元配列の**形 （shape）** が保存されています。\n",
        "上で定義した `a` という ndarray オブジェクトの形を調べてみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "O2GmnrGVhszq",
        "outputId": "b3cf41ce-66f9-434a-9082-22af7ed8ff9c"
      },
      "source": [
        "a.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YlU3JFZVhszw"
      },
      "source": [
        "`(3,)` という要素数が 1 の Python のタプルが表示されています。\n",
        "ndarray の形は、要素が整数のタプルで表され、要素数はその多次元配列の**次元数 （dimensionality, number of dimensions）** を表します。\n",
        "形は、その多次元配列の各次元の大きさを順に並べた整数のタプルになっています。\n",
        "\n",
        "次元数は、ndarray の `ndim` という属性に保存されています。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "TClptSKihszx",
        "outputId": "1a22e147-f5cb-4cca-d586-351891bef7dc"
      },
      "source": [
        "a.ndim"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ALEfYmAuhsz1"
      },
      "source": [
        "これは、`len(a.shape)` と同じ値になります。\n",
        "今、`a` という ndarray は 1 次元配列なので、`a.shape` は要素数が 1 のタプルで、`ndim` の値は 1 でした（[注釈3](#note3)）。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQcB5yZvhsz2"
      },
      "source": [
        "では次に、$3 \\times 3$ 行列を定義してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "u3MkTwo0jM1y",
        "outputId": "daed274d-9d7f-43b4-9b3b-3f729ce821ad"
      },
      "source": [
        "# 行列の定義\n",
        "b = np.array(\n",
        "    [[1, 2, 3],\n",
        "     [4, 5, 6],\n",
        "     [7, 8, 9]]\n",
        ")\n",
        "\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEZor0zths0B"
      },
      "source": [
        "形と次元数を調べます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "VdoPp_H3hs0C",
        "outputId": "d326c3de-28b0-40ba-d594-ff6befef3ceb"
      },
      "source": [
        "print('Shape:', b.shape)\n",
        "print('Rank:', b.ndim)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape: (3, 3)\n",
            "Rank: 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GRcKmhhRhs0G"
      },
      "source": [
        "ここで、`size` という属性も見てみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "nL7kUxyThs0H",
        "outputId": "a5a99a98-b7a6-4ff4-f71e-841259bf2801"
      },
      "source": [
        "b.size"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6qHL5knGhs0L"
      },
      "source": [
        "これは、`b` という ndarray が持つ要素の数を表しています。\n",
        "`b` は $3 \\times 3$ 行列なので、要素数は 9 です。\n",
        "**「形」「次元数」「サイズ」という言葉がそれぞれ意味するものの違いを確認してください。**\n",
        "\n",
        "NumPy の ndarray の作成方法には、`np.array()` を用いて Python のリストから多次元配列を作る方法以外にも、色々な方法があります。\n",
        "以下に代表的な例をいくつか紹介します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "-E2Rtwq9hs0N",
        "outputId": "8a89d4fb-508c-4328-8001-6837b331eed2"
      },
      "source": [
        "# 形を指定して、要素が全て 0 で埋められた ndarray を作る\n",
        "a = np.zeros((3, 3))\n",
        "\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "870IpdMyhs0R",
        "outputId": "b45b6bf4-22b8-495f-c15f-6e6467ef6fb9"
      },
      "source": [
        "# 形を指定して、要素が全て 1 で埋められた ndarray を作る\n",
        "b = np.ones((2, 3))\n",
        "\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1.],\n",
              "       [1., 1., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "xndboQKyhs0W",
        "outputId": "1371ef3d-043c-48dc-de8c-6d8d05f9cfdf"
      },
      "source": [
        "# 形と値を指定して、要素が指定した値で埋められた ndarray を作る\n",
        "c = np.full((3, 2), 9)\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[9, 9],\n",
              "       [9, 9],\n",
              "       [9, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "id": "WA5IUfrmhs0b",
        "outputId": "b3162424-a0a9-4110-dc3b-cb291a90ac91"
      },
      "source": [
        "# 指定された大きさの単位行列を表す ndarray を作る\n",
        "d = np.eye(5)\n",
        "\n",
        "d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0., 0., 0.],\n",
              "       [0., 1., 0., 0., 0.],\n",
              "       [0., 0., 1., 0., 0.],\n",
              "       [0., 0., 0., 1., 0.],\n",
              "       [0., 0., 0., 0., 1.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "id": "YLH4LMVThs0h",
        "scrolled": true,
        "outputId": "97b95b3c-ace3-4caf-ec13-d4e01d5d3c7d"
      },
      "source": [
        "# 形を指定して、 0 ~ 1 の間の乱数で要素を埋めた ndarray を作る\n",
        "e = np.random.random((4, 5))\n",
        "\n",
        "e"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.945015  , 0.43016639, 0.29548392, 0.95129474, 0.79083349],\n",
              "       [0.38302104, 0.81301269, 0.89543488, 0.98794199, 0.07312155],\n",
              "       [0.28104454, 0.05910526, 0.82286822, 0.80324149, 0.34598631],\n",
              "       [0.27901198, 0.99971565, 0.80767343, 0.8232321 , 0.53487828]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "JrlPdcOths0r",
        "outputId": "016d37ff-60d6-4aa1-cdb2-ad58154e10fe"
      },
      "source": [
        "# 3 から始まり 10 になるまで 1 ずつ増加する数列を作る（10 は含まない）\n",
        "f = np.arange(3, 10, 1)\n",
        "\n",
        "f"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1rPZMxVIhs0w"
      },
      "source": [
        "## 多次元配列の要素を選択する\n",
        "\n",
        "前節では NumPy を使って多次元配列を定義するいくつかの方法を紹介しました。\n",
        "本節では、作成した ndarray のうちの特定の要素を選択して、値を取り出す方法を紹介します。\n",
        "最もよく行われる方法は `[]` を使った**添字表記 （subscription）** による要素の選択です。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yjqfy8AVhs0x"
      },
      "source": [
        "### 整数による要素の選択\n",
        "\n",
        "例えば、上で作成した `e` という $4 \\times 5$ 行列を表す多次元配列から、1 行 2 列目の値を取り出すには、以下のようにします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "4wXjOOjyhs0y",
        "scrolled": true,
        "outputId": "6581d4a6-dc3c-46a5-cc00-c91923b2e7a4"
      },
      "source": [
        "val = e[0, 1]\n",
        "\n",
        "val"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.43016638598041224"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FPYVW5rqhs02"
      },
      "source": [
        "「1 行 2 列目」を指定するのに、インデックスは `[0, 1]` でした。\n",
        "これは、NumPy の ndarray の要素は Python リストと同じく、添字が 0 から始まる**ゼロベースインデックス （zero-based index）** が採用されているためです。\n",
        "つまり、この行列の i 行 j 列目の値は、`[i - 1, j - 1]` で取り出すことができます。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWnR7Eurhs03"
      },
      "source": [
        "### スライスによる要素の選択\n",
        "\n",
        "NumPy の ndarray に対しても、Python のリストと同様に**スライス表記 （slicing）** を用いて選択したい要素を範囲指定することができます。\n",
        "ndarray はさらに、カンマ区切りで複数の次元に対するスライスを指定できます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "Q0nqhCpfhs04",
        "scrolled": true,
        "outputId": "065d1646-ba1a-4b0c-92ef-36ea788ab8aa"
      },
      "source": [
        "# 4 x 5 行列 e の真ん中の 2 x 3 = 6 個の値を取り出す\n",
        "center = e[1:3, 1:4]\n",
        "\n",
        "center"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.81301269, 0.89543488, 0.98794199],\n",
              "       [0.05910526, 0.82286822, 0.80324149]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1FUL2bOkhs09"
      },
      "source": [
        "前節最後にある `e` の出力を見返すと、ちょうど真ん中の部分の $2 \\times 3$ 個の数字が取り出せていることが分かります。\n",
        "ここで、`e` の中から `[1, 1]` の要素を起点として 2 行 3 列を取り出して作られた `center` の形を、`e` の形と比較してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "g57LOQJbhs0_",
        "outputId": "5ad96c57-27ec-4a5e-99e0-f40747463619"
      },
      "source": [
        "print('Shape of e:', e.shape)\n",
        "print('Shape of center:', center.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape of e: (4, 5)\n",
            "Shape of center: (2, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5tbJR05ehs1F"
      },
      "source": [
        "また、インデックスを指定したり、スライスを用いて取り出した ndarray の一部に対し、値を代入することもできます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "id": "pnJGJ0sOhs1G",
        "outputId": "5b3be8f5-918e-4aaf-c304-4b08e52a0754"
      },
      "source": [
        "# 先程の真ん中の 6 個の値を 0 にする\n",
        "e[1:3, 1:4] = 0\n",
        "\n",
        "e"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.945015  , 0.43016639, 0.29548392, 0.95129474, 0.79083349],\n",
              "       [0.38302104, 0.        , 0.        , 0.        , 0.07312155],\n",
              "       [0.28104454, 0.        , 0.        , 0.        , 0.34598631],\n",
              "       [0.27901198, 0.99971565, 0.80767343, 0.8232321 , 0.53487828]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7n7aJGJahs1J"
      },
      "source": [
        "### 整数配列による要素の選択\n",
        "\n",
        "ndarray の `[]` には、整数やスライスの他に、整数配列を渡すこともできます。\n",
        "整数配列とは、ここでは整数を要素とする Python リストまたは ndarray のことを指しています。\n",
        "\n",
        "具体例を示します。\n",
        "まず、$3 \\times 3$ 行列を表す `a` という ndarray を定義します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "XxgfjK2-hs1L",
        "outputId": "83abf535-d424-4c6c-d37a-4f0b0124a25f"
      },
      "source": [
        "a = np.array(\n",
        "    [[1, 2, 3],\n",
        "     [4, 5, 6],\n",
        "     [7, 8, 9]]\n",
        ")\n",
        "\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6],\n",
              "       [7, 8, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qjX-7iNths1R"
      },
      "source": [
        "この ndarray から、\n",
        "\n",
        "1. 1 行 2 列目：`a[0, 1]`\n",
        "2. 3 行 2 列目：`a[2, 1]`\n",
        "3. 2 行 1 列目：`a[1, 0]`\n",
        "\n",
        "の 3 つの要素を選択して並べ、形が `(3,)` であるような ndarray を作りたいとします。\n",
        "\n",
        "これは、以下のように、順に対象の要素を指定して並べて新しい ndarray にすることでももちろん実現できます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "UvEgg_eHhs1S",
        "outputId": "3f27d554-9d09-4327-8138-4d2b5c085b16"
      },
      "source": [
        "np.array([a[0, 1], a[2, 1], a[1, 0]])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 8, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r2aNYWNFhs1V"
      },
      "source": [
        "しかし、同じことが**選択したい行、選択したい列を、順にそれぞれリストとして与える**ことでも行えます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "P1scHQiRhs1W",
        "outputId": "e0c1fe5d-4f63-4ba3-e3e9-8540b86f3b3e"
      },
      "source": [
        "a[[0, 2, 1], [1, 1, 0]]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 8, 4])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0sHruq-ohs1Z"
      },
      "source": [
        "**選択したい 3 つの値がどの行にあるか**だけに着目すると、それぞれ 1 行目、3 行目、2 行目にある要素です。  \n",
        "ゼロベースインデックスでは、それぞれ 0, 2, 1 行目です。  \n",
        "これが `a` の `[]` に与えられた 1 つ目のリスト `[0, 2, 1]` の意味です。  \n",
        "\n",
        "同様に、**列に着目**すると、ゼロベースインデックスでそれぞれ 1, 1, 0 列目の要素です。  \n",
        "これが `a` の `[]` に与えられた 2 つ目のリスト `[1, 1, 0]` の意味です。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HDdtMWR4hs1a"
      },
      "source": [
        "## ndarray のデータ型\n",
        "\n",
        "1 つの ndarray の要素は、全て同じ型を持ちます。\n",
        "NumPy では様々なデータ型を使うことができますが、ここでは一部だけを紹介します。\n",
        "NumPy は Python リストを渡して ndarray を作る際などには、その値からデータ型を推測します。\n",
        "ndarray のデータ型は、`dtype` という属性に保存されています。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eU6frncOhs1d",
        "outputId": "3f764b12-bb3c-4a65-89ad-159d980a2c34"
      },
      "source": [
        "# 整数（Python の int 型）の要素をもつリストを与えた場合\n",
        "x = np.array([1, 2, 3])\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3C4OQKq9hs1k",
        "outputId": "f46446f4-a54b-4278-846f-86b82e8c32d1"
      },
      "source": [
        "# 浮動小数点数（Python の float 型）の要素をもつリストを与えた場合\n",
        "x = np.array([1., 2., 3.])\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HTg_bqiuhs1o"
      },
      "source": [
        "以上のように、**Python の int 型は自動的に NumPy の int64 型**になりました。\n",
        "また、**Python の float 型は自動的に NumPy の float64 型**になりました。\n",
        "Python の int 型は NumPy の int_ 型に対応づけられており、Python の float 型は NumPy の float_ 型に対応づけられています。\n",
        "この int_ 型はプラットフォームによって int64 型と同じ場合と int32 型と同じ場合があります。\n",
        "float_ 型についても同様で、プラットフォームによって float64 型と同じ場合と float32 型と同じ場合があります。\n",
        "\n",
        "特定の型を指定して ndarray を作成するには、以下のようにします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3UZiigfFhs1p",
        "outputId": "c422ade7-f6dc-412f-c40f-9ee18c47685b"
      },
      "source": [
        "x = np.array([1, 2, 3], dtype=np.float32)\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float32')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aWMTSehbhs1s"
      },
      "source": [
        "このように、`dtype` という引数に NumPy の dtype オブジェクトを渡します。\n",
        "これは 32 ビット浮動小数点数型を指定する例です。\n",
        "同じことが、文字列で指定することによっても行えます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "jg3-zxU2yEpd",
        "outputId": "f59a3c33-7b99-42a3-8079-46d7bdd9b28e"
      },
      "source": [
        "x = np.array([1, 2, 3], dtype='float32')\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float32')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZ2hdYZ_yEph"
      },
      "source": [
        "これはさらに、以下のように短く書くこともできます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "tnn0EQQmyEpk",
        "outputId": "84a57ee4-0b87-40c2-ccb6-c1672b71f27a"
      },
      "source": [
        "x = np.array([1, 2, 3], dtype='f')\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float32')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wa5IPghnyEps"
      },
      "source": [
        "一度あるデータ型で定義した配列のデータ型を別のものに変更するには、`astype` を用いて変換を行います。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fnqEBxUMhs1t",
        "outputId": "1191035e-7a37-4a43-fbe6-70f59fe0fcc8"
      },
      "source": [
        "x = x.astype(np.float64)\n",
        "\n",
        "x.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('float64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQtt_qLLjeLQ"
      },
      "source": [
        "## 多次元配列を用いた計算\n",
        "\n",
        "ndarray を使って行列やベクトルを定義して、それらを用いていくつかの計算を行ってみましょう。\n",
        "\n",
        "ndarray として定義されたベクトルや行列同士の**要素ごとの加減乗除**は、Python の数値同士の四則演算に用いられる `+`、`-`、`*`、`/` という記号を使って行えます。\n",
        "\n",
        "それでは、同じ形の行列を 2 つ定義し、それらの**要素ごとの**加減乗除を実行してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_hpNMPZpw24s"
      },
      "source": [
        "# 同じ形 (3 x 3) の行列を 2 つ定義する\n",
        "a = np.array([\n",
        "    [0, 1, 2],\n",
        "    [3, 4, 5],\n",
        "    [6, 7, 8]\n",
        "])\n",
        "\n",
        "b = np.array([\n",
        "    [1, 2, 3],\n",
        "    [4, 5, 6],\n",
        "    [7, 8, 9]\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "O5zs75ooyEp2",
        "outputId": "1965d192-50d8-4cb0-9f3c-ac294f27db4a"
      },
      "source": [
        "# 足し算\n",
        "c = a + b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  3,  5],\n",
              "       [ 7,  9, 11],\n",
              "       [13, 15, 17]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "c2FOyv2YyEp5",
        "outputId": "fd28f151-0281-4e4f-a787-11db1d5ceeb0"
      },
      "source": [
        "# 引き算\n",
        "c = a - b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-1, -1, -1],\n",
              "       [-1, -1, -1],\n",
              "       [-1, -1, -1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "Pyiqo_ZYyEp8",
        "outputId": "436b891f-7d3b-4d30-afd2-7bca3f929955"
      },
      "source": [
        "# 掛け算\n",
        "c = a * b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  2,  6],\n",
              "       [12, 20, 30],\n",
              "       [42, 56, 72]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "Ut6N5zcTyEqA",
        "outputId": "6eda2f36-e116-47d0-a45c-afc344f4c968"
      },
      "source": [
        "# 割り算\n",
        "c = a / b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.        , 0.5       , 0.66666667],\n",
              "       [0.75      , 0.8       , 0.83333333],\n",
              "       [0.85714286, 0.875     , 0.88888889]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HFZIVmCwhs13"
      },
      "source": [
        "NumPy では、与えられた多次元配列に対して要素ごとに計算を行う関数が色々と用意されています。\n",
        "以下にいくつかの例を示します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "BUaEHDrcyEqL",
        "outputId": "57186cb3-188c-4b92-b354-8839496fa1de"
      },
      "source": [
        "# 要素ごとに平方根を計算する\n",
        "c = np.sqrt(b)\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1.        , 1.41421356, 1.73205081],\n",
              "       [2.        , 2.23606798, 2.44948974],\n",
              "       [2.64575131, 2.82842712, 3.        ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "X9XlfvFths14",
        "outputId": "94d8138e-36b9-4b7f-fe90-fc8bce1ee4a4"
      },
      "source": [
        "# 要素ごとに値を n 乗する\n",
        "n = 2\n",
        "c = np.power(b, n)\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  4,  9],\n",
              "       [16, 25, 36],\n",
              "       [49, 64, 81]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XC-OB1s_hs19"
      },
      "source": [
        "要素ごとに値を n 乗する計算は、以下のようにしても書くことができます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "7ekgNzVlhs2F",
        "outputId": "c1b1deb1-4f7c-45e3-fd02-a0319d00219a"
      },
      "source": [
        "c ** n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[   1,   16,   81],\n",
              "       [ 256,  625, 1296],\n",
              "       [2401, 4096, 6561]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9exqunixhs2K"
      },
      "source": [
        "はじめに紹介した四則演算は、**同じ大きさの** 2 つの行列同士で行っていました。\n",
        "ここで、$3 \\times 3$ 行列 `a` と 3 次元ベクトル `b` という大きさのことなる配列を定義して、それらを足してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "geIUaMashs2L",
        "outputId": "0cb165b3-98fc-477d-fc97-1c4f23e4c5e2"
      },
      "source": [
        "a = np.array([\n",
        "    [0, 1, 2],\n",
        "    [3, 4, 5],\n",
        "    [6, 7, 8]\n",
        "])\n",
        "\n",
        "b = np.array([1, 2, 3])\n",
        "\n",
        "c = a + b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  3,  5],\n",
              "       [ 4,  6,  8],\n",
              "       [ 7,  9, 11]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9dns4SENhs2T"
      },
      "source": [
        "形が同じ行列同士の場合と同様に計算することができました。\n",
        "\n",
        "これは NumPy が自動的に**ブロードキャスト（broadcast）**と呼ばれる操作を行っているためです。\n",
        "これについて次節で説明します。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zD5qR1Dvhs2V"
      },
      "source": [
        "## ブロードキャスト\n",
        "\n",
        "行列同士の要素ごとの四則演算は、通常は行列の形が同じでなければ定義できません。\n",
        "しかし、前節の最後では $3 \\times 3$ 行列に 3 次元ベクトルを足す計算が実行できました。\n",
        "\n",
        "これが要素ごとの計算と同じように実行できる理由は、NumPy が自動的に 3 次元ベクトル `b` を 3 つ並べてできる $3 \\times 3$ 行列を想定し、`a` と同じ形に揃える操作を暗黙に行っているからです。\n",
        "この操作を、**ブロードキャスト**と呼びます。\n",
        "\n",
        "算術演算を異なる形の配列同士で行う場合、NumPy は自動的に小さい方の配列を**ブロードキャスト**し、大きい方の配列と形を合わせます。\n",
        "ただし、この自動的に行われるブロードキャストでは、行いたい算術演算が、大きい方の配列の一部に対して**繰り返し行われる**ことで実現されるため、実際に小さい方の配列のデータをコピーして大きい配列をメモリ上に作成することは可能な限り避けられます。\n",
        "また、この繰り返しの計算は NumPy の内部の C 言語によって実装されたループで行われるため、高速です。\n",
        "\n",
        "よりシンプルな例で考えてみましょう。\n",
        "以下のような配列 `a` があり、この全ての要素を 2 倍にしたいとします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "65YCT4dzhs2W",
        "outputId": "df386959-2091-477f-9669-d9f4d72a8f80"
      },
      "source": [
        "a = np.array([1, 2, 3])\n",
        "\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zp1-yKjXhs2a"
      },
      "source": [
        "このとき、一つの方法は以下のように同じ形で要素が全て 2 である別の配列を定義し、これと要素ごとの積を計算するやり方です。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "-HXN6pyVhs2b",
        "outputId": "ffcd209d-a7c2-412e-b79c-fe6955675ff3"
      },
      "source": [
        "b = np.array([2, 2, 2])\n",
        "\n",
        "c = a * b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 4, 6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7XJ7T6Mhs2g"
      },
      "source": [
        "しかし、スカラの 2 をただ `a` に掛けるだけでも同じ結果が得られます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "XUC3S8jqhs2h",
        "outputId": "a27f7d90-c84a-4339-c152-a185dfc60a42"
      },
      "source": [
        "c = a * 2\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 4, 6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SLje0bp-hs2k"
      },
      "source": [
        "`* 2` という計算が、`c` の 3 つの要素の**どの要素に対する計算なのか**が明示されていないため、NumPy はこれを**全ての要素に対して行うという意味**だと解釈して、スカラの 2 を `a` の要素数 3 だけ引き伸ばしてから掛けてくれます。\n",
        "\n",
        "**形の異なる配列同士の計算がブロードキャストによって可能になるためにはルールがあります。**\n",
        "\n",
        "それは、**「2 つの配列の各次元が同じ大きさになっているか、どちらかが 1 であること」**です。\n",
        "このルールを満たさない場合、NumPy は \"ValueError: operands could not be broadcast together with shapes (1 つ目の配列の形) (2 つ目の配列の形)\" というエラーを出します。\n",
        "\n",
        "ブロードキャストされた配列の各次元のサイズ（[注釈4](#note4)）は、入力された配列のその次元のサイズの中で最大の値と同じになっています。\n",
        "入力された配列は、各次元のサイズが入力のうち大きい方のサイズと同じになるようブロードキャストされ、その拡張されたサイズで計算されます。\n",
        "\n",
        "もう少し具体例を見てみましょう。\n",
        "以下のような 2 つの配列 `a` と `b` を定義し、足します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 444
        },
        "id": "bD4dr8ilhs2l",
        "outputId": "c2a409b2-2d67-4ad4-85d1-ce8ed42a03c3"
      },
      "source": [
        "# 0 ~ 9 の範囲の値をランダムに用いて埋められた (2, 1, 3) と (3, 1) という大きさの配列を作る\n",
        "a = np.random.randint(0, 10, (2, 1, 3))\n",
        "b = np.random.randint(0, 10, (3, 1))\n",
        "\n",
        "print('a:\\n', a)\n",
        "print('\\na.shape:', a.shape)\n",
        "print('\\nb:\\n', b)\n",
        "print('\\nb.shape:', b.shape)\n",
        "\n",
        "# 加算\n",
        "c = a + b\n",
        "\n",
        "print('\\na + b:\\n', c)\n",
        "print('\\n(a + b).shape:', c.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a:\n",
            " [[[6 2 0]]\n",
            "\n",
            " [[1 9 7]]]\n",
            "\n",
            "a.shape: (2, 1, 3)\n",
            "\n",
            "b:\n",
            " [[6]\n",
            " [2]\n",
            " [8]]\n",
            "\n",
            "b.shape: (3, 1)\n",
            "\n",
            "a + b:\n",
            " [[[12  8  6]\n",
            "  [ 8  4  2]\n",
            "  [14 10  8]]\n",
            "\n",
            " [[ 7 15 13]\n",
            "  [ 3 11  9]\n",
            "  [ 9 17 15]]]\n",
            "\n",
            "(a + b).shape: (2, 3, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o90A_pvhhs2u"
      },
      "source": [
        "`a` の形は `(2, 1, 3)` で、`b` の形は `(3, 1)` でした。\n",
        "この 2 つの配列の**末尾次元 (trailing dimension)**（[注釈5](#note5)） はそれぞれ 3 と 1 なので、ルールにあった「次元が同じサイズであるか、どちらかが 1 であること」を満たしています。\n",
        "\n",
        "次に、各配列の第 2 次元に注目してみましょう。\n",
        "それぞれ 1 と 3 です。\n",
        "これもルールを満たしています。\n",
        "\n",
        "ここで、`a` は 3 次元配列ですが、`b` は 2 次元配列です。\n",
        "つまり、次元数が異なっています。\n",
        "このような場合は、`b` は**一番上の次元にサイズが 1 の次元が追加された形** `(1, 3, 1)` として扱われます。\n",
        "そして 2 つの配列の各次元ごとのサイズの最大値をとった形 `(2, 3, 3)` にブロードキャストされ、足し算が行われます。\n",
        "\n",
        "このように、もし 2 つの配列のランクが異なる場合は、次元数が小さい方の配列が大きい方と同じ次元数になるまでその形の先頭に新たな次元が追加されます。\n",
        "サイズが 1 の次元がいくつ追加されても、要素の数は変わらないことに注意してください。\n",
        "要素数（`size` 属性で取得できる値）は、各次元のサイズの掛け算になるので、1 を何度かけても値は変わらないことから、これが成り立つことが分かります。\n",
        "\n",
        "NumPy がブロードキャストのために自動的に行う新しい次元の挿入は、`[]` を使った以下の表な表記を用いることで**手動で行うこともできます。**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "6TwzCz9khs2v",
        "outputId": "b9390767-8ba0-4567-a7a7-dd5999cf4673"
      },
      "source": [
        "print('Original shape:', b.shape)\n",
        "\n",
        "b_expanded = b[np.newaxis, :, :]\n",
        "\n",
        "print('Added new axis to the top:', b_expanded.shape)\n",
        "\n",
        "b_expanded2 = b[:, np.newaxis, :]\n",
        "\n",
        "print('Added new axis to the middle:', b_expanded2.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original shape: (3, 1)\n",
            "Added new axis to the top: (1, 3, 1)\n",
            "Added new axis to the middle: (3, 1, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g3CSUaHAhs20"
      },
      "source": [
        "`np.newaxis` が指定された位置に、新しい次元が挿入されます。\n",
        "配列が持つ数値の数は変わっていません。\n",
        "そのため、挿入された次元のサイズは必ず 1 になります。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "eK7NmjCWhs21",
        "outputId": "cacfe9cc-76ec-4aec-ef10-d93662a75d3c"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[6],\n",
              "       [2],\n",
              "       [8]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "wappsylzhs2_",
        "outputId": "30ed68c3-b11a-48d3-98bc-04fc0ea4fbdf"
      },
      "source": [
        "b_expanded"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[6],\n",
              "        [2],\n",
              "        [8]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "id": "l-IHRhU1hs3E",
        "outputId": "1b1c6f57-b8f6-421b-bb18-b254d3b4b355"
      },
      "source": [
        "b_expanded2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[6]],\n",
              "\n",
              "       [[2]],\n",
              "\n",
              "       [[8]]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mv8XZb4Bhs3I"
      },
      "source": [
        "NumPy のブロードキャストは慣れるまで直感に反するように感じる場合があるかもしれません。\n",
        "しかし、使いこなすと同じ計算が Python のループを使って行うよりも高速に行えるため、ブロードキャストを理解することは非常に重要です。\n",
        "一つ具体例を見てみます。\n",
        "\n",
        "$5 \\times 5$ 行列 `a` に、3 次元ベクトル `b` を足します。\n",
        "まず、`a`、`b` および結果を格納する配列 `c` を定義します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KW3-2Gz3hs3J"
      },
      "source": [
        "a = np.array([\n",
        "    [0, 1, 2, 1, 0],\n",
        "    [3, 4, 5, 4, 3],\n",
        "    [6, 7, 8, 7, 6],\n",
        "    [3, 4, 5, 4, 4],\n",
        "    [0, 1, 2, 1, 0]\n",
        "])\n",
        "\n",
        "b = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# 結果を格納する配列を先に作る\n",
        "c = np.empty((5, 5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CaPTRYq1hs3L"
      },
      "source": [
        "`%%timeit` という Jupyter Notebook で使用できるそのセルの実行時間を計測するためのマジックを使って、`a` の各行（1 次元目）に `b` の値を足していく計算を Python のループを使って 1 行ずつ処理していくコードの実行時間を測ってみます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "aTJ5owYUhs3M",
        "outputId": "91ad0294-e6ba-4b39-d536-a5563b1bd612"
      },
      "source": [
        "%%timeit\n",
        "for i in range(a.shape[0]):\n",
        "    c[i, :] = a[i, :] + b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The slowest run took 90.12 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "100000 loops, best of 3: 7.44 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "id": "-6z4EGzXhs3Q",
        "outputId": "ea6f591f-4841-45b6-f460-7bd7f9a032c7"
      },
      "source": [
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  3.,  5.,  5.,  5.],\n",
              "       [ 4.,  6.,  8.,  8.,  8.],\n",
              "       [ 7.,  9., 11., 11., 11.],\n",
              "       [ 4.,  6.,  8.,  8.,  9.],\n",
              "       [ 1.,  3.,  5.,  5.,  5.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3KXentjEhs3T"
      },
      "source": [
        "次に、NumPy のブロードキャストを活用した方法で同じ計算を行ってみます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "id": "pCgJcwt7hs3T",
        "outputId": "5af58db9-d332-4d80-ee1c-938df607a7e6"
      },
      "source": [
        "%%timeit\n",
        "c = a + b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The slowest run took 32.88 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 3: 1.13 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        },
        "id": "EAetPXrphs3Z",
        "outputId": "8d13e5ef-e68a-4bcd-d507-0086653a78ff"
      },
      "source": [
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.,  3.,  5.,  5.,  5.],\n",
              "       [ 4.,  6.,  8.,  8.,  8.],\n",
              "       [ 7.,  9., 11., 11., 11.],\n",
              "       [ 4.,  6.,  8.,  8.,  9.],\n",
              "       [ 1.,  3.,  5.,  5.,  5.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USEUvvcChs3c"
      },
      "source": [
        "計算結果は当然同じになります。\n",
        "しかし、実行時間が数倍短くなっています。\n",
        "\n",
        "このように、ブロードキャストを理解して活用することで、記述が簡単になるだけでなく、実行速度という点においても有利になります。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Fd_G9JckA0Z"
      },
      "source": [
        "## 行列積\n",
        "\n",
        "行列の要素ごとの積は `*` を用いて計算できました。\n",
        "一方、通常の行列同士の積（行列積）の計算は、`*` ではなく、別の方法で行います。\n",
        "方法は 2 種類あります。\n",
        "\n",
        "1つは、`np.dot()` 関数を用いる方法です。\n",
        "`np.dot()` は 2 つの引数をとり、それらの行列積を計算して返す関数です。\n",
        "今、`A` という行列と `B` という行列があり、行列積 `AB` を計算したいとします。\n",
        "これは `np.dot(A, B)` と書くことで計算できます。\n",
        "もし `BA` を計算したい場合は、`np.dot(B, A)` と書きます。\n",
        "\n",
        "もう 1 つは、ndarray オブジェクトが持つ `dot()` メソッドを使う方法です。\n",
        "これを用いると、同じ計算が `A.dot(B)` と書くことによって行えます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_rMylHNEhpFs"
      },
      "source": [
        "# 行列 A の定義\n",
        "A = np.array([\n",
        "    [0, 1, 2],\n",
        "    [3, 4, 5],\n",
        "    [6, 7, 8]\n",
        "])\n",
        "\n",
        "# 行列 B の定義\n",
        "B = np.array([\n",
        "    [1, 2, 3],\n",
        "    [4, 5, 6],\n",
        "    [7, 8, 9]\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-mVIroIhs3j"
      },
      "source": [
        "実際にこの $3 \\times 3$ の 2 つの行列の行列積を計算してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "Go9DfbmXhs3l",
        "outputId": "6b11a289-b91f-4944-fb63-f41f61feb496"
      },
      "source": [
        "# 行列積の計算 (1)\n",
        "C = np.dot(A, B)\n",
        "\n",
        "C"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 18,  21,  24],\n",
              "       [ 54,  66,  78],\n",
              "       [ 90, 111, 132]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FNU92PFPhs3o"
      },
      "source": [
        "同じ計算をもう一つの記述方法で行ってみます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "-YmjkeC8hs3p",
        "outputId": "a6b3774a-f02f-4029-d721-f15140be7e05"
      },
      "source": [
        "C = A.dot(B)\n",
        "\n",
        "C"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 18,  21,  24],\n",
              "       [ 54,  66,  78],\n",
              "       [ 90, 111, 132]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "E6UqcewwoFOv",
        "outputId": "be98d878-fdc0-4ea3-b152-cc093bd3628a"
      },
      "source": [
        "# データ型の確認（整数値）\n",
        "a.dtype"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4SH7NONRpfO1"
      },
      "source": [
        "## 基本的な統計量の求め方\n",
        "\n",
        "本節では、多次元配列に含まれる値の平均・分散・標準偏差・最大値・最小値といった統計値を計算する方法を紹介します。\n",
        "$8 \\times 10$ の行列を作成し、この中に含まれる値全体に渡るこれらの統計値を計算してみましょう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "id": "QtRVfBYahs3w",
        "outputId": "abeeb50a-9f79-43c4-ab98-c754885dbda9"
      },
      "source": [
        "x = np.random.randint(0, 10, (8, 10))\n",
        "\n",
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 8, 3, 3, 0, 7, 0, 8, 7, 4],\n",
              "       [7, 0, 8, 4, 3, 1, 7, 7, 4, 3],\n",
              "       [7, 4, 5, 5, 9, 5, 2, 4, 5, 2],\n",
              "       [4, 3, 6, 8, 0, 1, 5, 8, 4, 9],\n",
              "       [1, 8, 1, 0, 6, 7, 1, 2, 8, 3],\n",
              "       [8, 6, 0, 8, 0, 8, 6, 4, 8, 4],\n",
              "       [6, 7, 5, 5, 7, 2, 2, 8, 4, 8],\n",
              "       [4, 4, 2, 3, 8, 8, 1, 6, 1, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Vrkpn1d4qBNF",
        "outputId": "f0f3154b-bf1f-4acc-d14d-9b1bd1dde7b4"
      },
      "source": [
        "# 平均値\n",
        "x.mean()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.65"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Y_50qftbhs34",
        "outputId": "f0a8f5db-8c8e-465a-fd5c-4f788c0aae14"
      },
      "source": [
        "# 分散\n",
        "x.var()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.5025"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "OwpUSNzeqMLq",
        "outputId": "f8abd453-55cf-4465-cd41-7c8d94982389"
      },
      "source": [
        "# 標準偏差\n",
        "x.std()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.7390691849604676"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "xw_9lddYqcHF",
        "outputId": "5230bc25-d738-4220-9c83-f73dbd067765"
      },
      "source": [
        "# 最大値\n",
        "x.max()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "zls9oBfsqfJn",
        "outputId": "873c3f93-0116-42f7-df85-4b50bce5b762"
      },
      "source": [
        "# 最小値\n",
        "x.min()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wLLCGMeLhs4I"
      },
      "source": [
        "ここで、`x` は 2 次元配列なので、各次元に沿ったこれらの統計値の計算も行えます。\n",
        "例えば、最後の次元内だけで平均をとると、8 個の平均値が得られるはずです。\n",
        "平均を計算したい軸（何次元目に沿って計算するか）を `axis` という引数に指定します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "uvfzeCY3hs4I",
        "outputId": "b68937c7-a415-42a4-b7e5-1f6b79df82de"
      },
      "source": [
        "x.mean(axis=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4.3, 4.4, 4.8, 4.8, 3.7, 5.2, 5.4, 4.6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4be3BgZ6hs4M"
      },
      "source": [
        "これは、以下のように 1 次元目の値の平均を計算していったものを並べているのと同じことです。\n",
        "（ゼロベースインデックスで考えています。`x` の形は `(8, 10)` なので、0 次元目のサイズが 8、1 次元目のサイズが 10 です。）"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "sjqqYnSths4N",
        "outputId": "898b5fbd-4e31-4717-8f0b-d5373f214c80"
      },
      "source": [
        "np.array([\n",
        "    x[0, :].mean(),\n",
        "    x[1, :].mean(),\n",
        "    x[2, :].mean(),\n",
        "    x[3, :].mean(),\n",
        "    x[4, :].mean(),\n",
        "    x[5, :].mean(),\n",
        "    x[6, :].mean(),\n",
        "    x[7, :].mean(),\n",
        "])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4.3, 4.4, 4.8, 4.8, 3.7, 5.2, 5.4, 4.6])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rulZyy5osZxR"
      },
      "source": [
        "## NumPy を用いた重回帰分析\n",
        "\n",
        "[単回帰分析と重回帰分析](https://tutorials.chainer.org/ja/07_Regression_Analysis.html)の章で説明した重回帰分析を NumPy を用いて行いましょう。\n",
        "\n",
        "4 つのデータをまとめた、以下のようなデザイン行列が与えられたとします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "id": "0grPocVNvn3P",
        "outputId": "1727f10c-dc5c-4864-937b-61a4e0fb4581"
      },
      "source": [
        "# Xの定義\n",
        "X = np.array([\n",
        "    [2, 3],\n",
        "    [2, 5],\n",
        "    [3, 4],\n",
        "    [5, 9],\n",
        "])\n",
        "\n",
        "X"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 3],\n",
              "       [2, 5],\n",
              "       [3, 4],\n",
              "       [5, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1T4NGECihs4b"
      },
      "source": [
        "4 章の解説と同様に、切片を重みベクトルに含めて扱うため、デザイン行列の 0 列目に 1 という値を付け加えます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        },
        "id": "aSSfzZoahs4d",
        "outputId": "0d1dbc3e-12cd-4bf5-bfca-fc8bb256a79e"
      },
      "source": [
        "# データ数（X.shape[0]) と同じ数だけ 1 が並んだ配列\n",
        "ones = np.ones((X.shape[0], 1))\n",
        "\n",
        "# concatenate を使い、1 次元目に 1 を付け加える\n",
        "X = np.concatenate((ones, X), axis=1)\n",
        "\n",
        "# 先頭に 1 が付け加わったデザイン行列\n",
        "X"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 2., 3.],\n",
              "       [1., 2., 5.],\n",
              "       [1., 3., 4.],\n",
              "       [1., 5., 9.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DQ9Ybyrphs4g"
      },
      "source": [
        "また、目標値が以下で与えられたとします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eU0UlmKrvxVK",
        "outputId": "7fb37396-09f2-427b-f52f-769b587f1b4c"
      },
      "source": [
        "# t の定義\n",
        "t = np.array([1, 5, 6, 8])\n",
        "\n",
        "t"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 5, 6, 8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UX4hYhjtwBlK"
      },
      "source": [
        "重回帰分析は、正規方程式を解くことで最適な 1 次方程式の重みを決定することができました。\n",
        "正規方程式の解は以下のようなものでした。\n",
        "\n",
        "$$\n",
        "{\\bf w} = ({\\bf X}^{{\\rm T}}{\\bf X})^{\\rm -1}{\\bf X}^{\\rm T}{\\bf t}\n",
        "$$\n",
        "\n",
        "これを、4 つのステップに分けて計算していきます。\n",
        "\n",
        "まずは、${\\bf X}^{\\rm T}{\\bf X}$ の計算です。ndarrayに対して `.T` で転置した配列を得られます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "r_s8lxK9wvFW",
        "outputId": "5ea9564a-8e50-4db9-f334-1d38eb14f40d"
      },
      "source": [
        "# Step 1\n",
        "xx = np.dot(X.T, X)\n",
        "\n",
        "xx"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  4.,  12.,  21.],\n",
              "       [ 12.,  42.,  73.],\n",
              "       [ 21.,  73., 131.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1x4UD4Tghs4v"
      },
      "source": [
        "次に、この逆行列を計算します。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "id": "V4ZpY_CLxuRX",
        "outputId": "1d4c9b86-c4e8-487c-afe7-6d5b09eb2508"
      },
      "source": [
        "# Step 2\n",
        "xx_inv = np.linalg.inv(xx)\n",
        "\n",
        "xx_inv"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1.76530612, -0.39795918, -0.06122449],\n",
              "       [-0.39795918,  0.84693878, -0.40816327],\n",
              "       [-0.06122449, -0.40816327,  0.24489796]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s40OeZJ0yJw5"
      },
      "source": [
        "逆行列の計算は `np.linalg.inv()` で行うことができます。\n",
        "\n",
        "次に、${\\bf X}^{\\rm T}{\\bf t}$ の計算をします。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "YR6kbSD1x3XU",
        "scrolled": true,
        "outputId": "3ed492c2-175e-4e0b-eeea-8c4d18758804"
      },
      "source": [
        "# Step 3\n",
        "xt = np.dot(X.T, t)\n",
        "\n",
        "xt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 20.,  70., 124.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 66
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "94huqVEDhs40"
      },
      "source": [
        "最後に、求めた `xx_inv` と `xt` を掛け合わせます。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "oBBA-NRbybHK",
        "outputId": "e7e35e3c-2566-473e-88dd-09a0ef7790e1"
      },
      "source": [
        "# Step 4\n",
        "w = np.dot(xx_inv, xt)\n",
        "\n",
        "w"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.14285714,  0.71428571,  0.57142857])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XsIpR4_ehs43"
      },
      "source": [
        "**以上の計算は、以下のように 1 行で行うこともできます。**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "SXPsTsIxhs43",
        "outputId": "c862c977-b762-480d-bcd1-cece5355ff10"
      },
      "source": [
        "w_ = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(t)\n",
        "\n",
        "w_"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.14285714,  0.71428571,  0.57142857])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k9xtcA31mXD-"
      },
      "source": [
        "実際には逆行列を陽に求めることは稀で、連立一次方程式を解く、すなわち逆行列を計算してベクトルに掛けるのに等しい計算をひとまとめに行う関数 `numpy.linalg.solve` を呼ぶ方が速度面でも精度面でも有利です。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "rL5mO_Srm7Xe",
        "outputId": "8cf416e8-031b-4269-e8c2-7406ed3c5630"
      },
      "source": [
        "w_ = np.linalg.solve(X.T.dot(X), X.T.dot(t))\n",
        "\n",
        "w_"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.14285714,  0.71428571,  0.57142857])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxZkwFz8hs45"
      },
      "source": [
        "数式を NumPy による配列の計算に落とし込むことに慣れていくには少し時間がかかりますが、慣れると少ない量のコードで記述できるだけでなく、高速に計算が行なえるため、大きな恩恵があります。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ky_Jm7KjyEsx"
      },
      "source": [
        "<hr />\n",
        "\n",
        "<div class=\"alert alert-info\">\n",
        "**注釈 1**\n",
        "\n",
        "ライブラリとは、汎用性の高い複数の関数やクラスなどを再利用可能な形でひとまとまりにしたもので、Python の世界では**パッケージ**とも呼ばれます。また、Python で関数やクラスの定義、文などが書かれたファイルのことを**モジュール**と呼び、パッケージはモジュールが集まったものです。\n",
        "\n",
        "[▲上へ戻る](#ref_note1)\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-info\">\n",
        "**注釈 2**\n",
        "\n",
        "NumPy には matrix というクラスも存在しますが、本チュートリアルでは基本的に多次元配列を表す ndarray をベクトルや行列を表すために用います。\n",
        "\n",
        "[▲上へ戻る](#ref_note2)\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-info\">\n",
        "**注釈 3**\n",
        "\n",
        "これは、その多次元配列が表すテンソルの**階数（rank、以下ランク）**と対応します。\n",
        "\n",
        "[▲上へ戻る](#ref_note3)\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-info\">\n",
        "**注釈 4**\n",
        "    \n",
        "「次元のサイズ」と言った場合はその次元の大きさを意味し、配列の `size` 属性とは異なるものを指しています。\n",
        "\n",
        "[▲上へ戻る](#ref_note4)\n",
        "</div>\n",
        "\n",
        "<div class=\"alert alert-info\">\n",
        "**注釈 5**\n",
        "    \n",
        "末尾次元（trailing dimension）とは、その配列の形を表すタプルの一番最後の値のことを指します。\n",
        "\n",
        "[▲上へ戻る](#ref_note5)\n",
        "</div>"
      ]
    }
  ]
}