0_numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "0-numpy.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "JPq9Zh8Ekg9n"
      ],
      "toc_visible": true,
      "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.6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JSJeong-me/2021-K-Digital-Training/blob/main/0_numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XOmhYVEwXIcH"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/jS2nj0Ju7rvJJangnpFrnveoLlMAVc-Ee-k38WW3bRT1rpOooDKa8c3Uh2hZs5j6-XNc1ZFry07GtQTX8sYRpyZGgz8TZuBpGw75pAZqSKQRSfKA0Isy3I-222AHDlZa1WNAvFGmQLfeR4S96qK3agRN-br82Od1243W4uVZbFmbkZPykYy4_qDeE2UrbT1nVr8QZccLXjjtjiJRM8WQ_8eZFSRUBP1BMQg5AG6l7tdGXuWlQDmqFOFcDcEQE5ZX30N7TIcDSOiMWjp0gGZgtMfaR983h4NP8dUp-ej-Vo1D4FSpa_zTpjvKRrpbfnVir1LpIw0yC9OjD7aCMtLcul9Npe-voMkiJgz5XNvFatCgq5WmfcoaDDvkkEQZgp7LQoOqqprzvdItdiyWagMtCVQONtypoZhc2kQQkfav2M0sC9kG4AXDJ6nOlpi8iSbJSVVPKHN9wzGzN1gxo2dDtaua9VfHd5MTOWiRV6ArL6pzwzSzAPSAgUFZZhc4RHGzk5ChHsJBaO3gzvn8GF4Cr7P7GahgXEhw98u1Z0VlNqDmp37B4cUHm5dujBm7jQXGTvPqM5zuDHwiviFId6OMjcjW6xZNckM9_KM8opmUYN_RKP-YPs51qrz9NVksS73JOhHpBHtVQMDCFycT6ZSKv-zdwZN7_FW7=w2160-h856-no)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6cMgoMfCa04s"
      },
      "source": [
        "# 들어가며"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RbbfuWbnYG4p"
      },
      "source": [
        "## Google Colab 사용 방법"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N-19yBZf9p0X"
      },
      "source": [
        "- 방향키 ↑↓: 셀 간 이동\n",
        "- Enter: 편집모드\n",
        "- Ctrl + Enter: 셀 실행\n",
        "- Shift + Enter: 셀 실행 + 다음 셀 선택\n",
        "\n",
        "---\n",
        "\n",
        "- Ctrl +M D: 셀 삭제\n",
        "- Ctrl + M K: 셀 위로 이동\n",
        "- Ctrl + M J: 셀 아래로 이동"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lzIDPJDeUOjE"
      },
      "source": [
        "# NumPy의 존재 이유\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ph6QEFZ7hH7n"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/AP7oMf3hAk2jjhu_cHRNZ6JHxjOZ9FOtthMkSw_wPoRBgSuroW8s4BhP5vAeOrMoBlc7fTeX79ItwpWn5Wmek4wunewkSVe_emEmmFxJUlFbM-a4mFE06ghc5dmpsa9pIRbXQbadTpnOYw9lY9Ujr-UKp5rqi_-IUEh7SFUoWhcGv2ch60Kz3u1j0TWukwW4xCOXd85gkesdMHsaMo_qllLu1mzWeIrABxeASD3n8RuWyiETGJruH5mpiq0X7PkprxJkbwTmaOfwQTolZp64xW05yvXb2xEN_dJuHaWvhCdX05RVcqjw6JjWrqnmLKSwYKgHUy-l4yXBgsZFSh0Vi-di4-DB4e5LxNJa_9ykJuC9sr_msdeub6EMBJnvwziHIkdqwmfUUEl13EHFpkbt2AsJVeSj-ctJTUIxGCx1kD2OPA0VID_BTNpJDBXH1RtMC8JoRysIClD4NVL0tSh96R0ZownNqE8FZlextg86VQuhP7_CRSFtuEdzD5I0SxHDqPWhHzA9Okb5gmDwBykEf55jla53ta1thdxwKG8uJAm9ksW0lnsmG7HcA0l6UJibRJVhnf4-jEmJ_0CvCQ61rf0lbP_-bJOGOy3HZP5NrqOfVbJvX0Ey9UYURK1H7XuhDdydyTi4JY_V-7htYv7RxKUTED5Bd7R1WiQnCIYwbrDPbTyR6KHZgO7ydMp37hOlr9Fw745ASonaxuyPA2XTdRSCXg=w708-h371-no)\n",
        "\n",
        "NumPy는 Pandas, Scikit-learn, Tensorflow등 데이터 사이언스 분야에서 사용되는 라이브러리들의 토대가 되는 라이브러리입니다. NumPy 그 자체로는 높은 수준의 데이터 분석 기능을 제공하지 않지만 NumPy를 활용해 데이터를 Python상에서 표현하고 다룰 줄 알아야만 데이터 분석이라는 그 이후 단계로 나아갈 수 있습니다.\n",
        "\n",
        "이번 강의에서는 데이터 분석의 토대가 될 NumPy의 기본 기능들과 더 빠르고 효율적인 연산을 위한 NumPy 활용법들을 다룰 예정입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-532MytnX9MS"
      },
      "source": [
        "## 데이터 과학에서 다차원 배열의 필요성"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojfCyAcWzZvz"
      },
      "source": [
        "### 리스트 자료형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G5_DhNL4o3Fs"
      },
      "source": [
        "추가된 데이터를 새로 선언해 주는것은 어쩔수 없다 하더라도 합과 평균을 구하는 코드를 매번 변경하는건 비효율적인 일입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YndLMp1Zznur"
      },
      "source": [
        "리스트 자료형에 데이터를 저장하면 이 문제를 해결할 수 있습니다.\n",
        "\n",
        "다섯명의 학생들로 이루어진 반이 있고 이 학생들의 수학점수를 **리스트**에 저장하는 경우 아래처럼 처리할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RkZXCTbMyvDz",
        "outputId": "0d62105f-7d40-4cab-e687-0856e095df81"
      },
      "source": [
        "MathScoreList = [11, 12, 13]\n",
        "\n",
        "print(MathScoreList)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[11, 12, 13]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "arCJlQ3J0RY5"
      },
      "source": [
        "점수들의 합과, 평균은 아래처럼 구할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0nfV0KGFfU3a",
        "outputId": "553eb7ec-1d92-4ab1-c131-4137ece3258c"
      },
      "source": [
        "listMathScoreSum = 0      # 변수 선언&초기화\n",
        "listMathScoreAverage = 0  # 변수 선언&초기화\n",
        "\n",
        "for e in MathScoreList:\n",
        "  listMathScoreSum += e   # listMathScoreSum = listMathScoreSum + e 와 동일한 코드\n",
        "  \n",
        "listMathScoreAverage = listMathScoreSum / len(MathScoreList)\n",
        "\n",
        "print(\"수학점수 합: {}\".format(listMathScoreSum))\n",
        "print(\"수학점수 평균: {}\".format(listMathScoreAverage))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "수학점수 합: 36\n",
            "수학점수 평균: 12.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iyULeL49s1o3"
      },
      "source": [
        "만약 새로운 학생이 전학을 와서 시험을 쳤고 이 학생의 성적을 추가한 점수들의 합과 평균을 구하려면 어떻게 해야 할까요?\n",
        "\n",
        "새로운 변수를 추가해야 합니다.\n",
        "\n",
        "기존의 리스트에 새로운 데이터를 추가하면 됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XLU6-OJO02Pq"
      },
      "source": [
        "# append: list의 끝에 요소를 추가할 때 사용하는 메서드\n",
        "MathScoreList.append(14)  # 데이터 추가"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WwlsHrpO06-B"
      },
      "source": [
        "그리고 합과 평균을 구하는 코드 역시 수정해야합니다.\n",
        "\n",
        "새로운 데이터가 추가되더라도 평균과 합을 구하는 **코드는 수정 없이 그대로 사용할 수 있습니다**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hZ9b6Es8fU1Q"
      },
      "source": [
        "listMathScoreSum = 0      # 변수 선언&초기화\n",
        "listMathScoreAverage = 0  # 변수 선언&초기화\n",
        "\n",
        "for e in MathScoreList:\n",
        "  listMathScoreSum += e   # listMathScoreSum = listMathScoreSum + e 와 동일한 코드\n",
        "  \n",
        "listMathScoreAverage = listMathScoreSum / len(MathScoreList)\n",
        "\n",
        "print(\"수학점수 합: {}\".format(listMathScoreSum))\n",
        "print(\"수학점수 평균: {}\".format(listMathScoreAverage))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HaiPjaN4lgr0"
      },
      "source": [
        "만약 시험문제의 오류가 발견되어 모두 정답처리를 해 모든 학생의 점수를 1점씩 올려줘야 하는 상황에서는 어떻게 해야할까요?\n",
        "\n",
        "반복문이나 List comprehension같은 방법이 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gwRCBixOvF4R"
      },
      "source": [
        "**반복문**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DWLrwbYJvF4J",
        "outputId": "91058d46-2ee2-4563-d824-4955eb589486"
      },
      "source": [
        "MathScoreList2 = []\n",
        "for e in MathScoreList:\n",
        "  MathScoreList2.append(e+1)\n",
        "  \n",
        "\n",
        "print(MathScoreList2)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[12, 13, 14, 15]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JhKvljj4nxEh"
      },
      "source": [
        "**List Comprehension**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5eViBzeRjmxp"
      },
      "source": [
        "MathScoreList3 = [e +1 for e in MathScoreList]\n",
        "\n",
        "print(MathScoreList3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fx6d-Cq8X9HP"
      },
      "source": [
        "## 파이썬 기본 자료형으로 구현한 다차원 배열"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-7ZLOVbu798"
      },
      "source": [
        "#### Nested List (중첩 리스트)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C-611O6VyZek"
      },
      "source": [
        "1반의 점수가 11, 12, 13\n",
        "\n",
        "2반의 점수가 21, 22, 23\n",
        "\n",
        "3반의 점수가 31, 32, 33점이라고 한다면,\n",
        "\n",
        "리스트 안에 리스트를 넣어 위 데이터를 아래처럼 나타낼 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MZU0pOw4u48h",
        "outputId": "a1493493-c2e9-41d0-9bbd-1462fa547db3"
      },
      "source": [
        "MathScoreNestedList = [[11, 12, 13], [21, 22, 23], [31, 32, 33]]\n",
        "\n",
        "print(MathScoreNestedList)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11, 12, 13], [21, 22, 23], [31, 32, 33]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lc76UfCXvO06"
      },
      "source": [
        "<p class=\"aligncenter\">\n",
        "    <img src=\"https://lh3.googleusercontent.com/pQw2wvQVpsV40t7Uk6O-iNMwVX0GUesvvA-snrEVl1lGWeRsrDjU-2YlkO0jlW7XFMmQNVQchD1XM4sbWVSPtTWjvSc50mY2iuFKNYc72N-rSvymejq4dCpuG4WeheZ2M4tqkJzO37xcujHDe4MJNc0URISUgTXt2452rMh2wDrCVKOa0Ywh85x3cqL9IRYJxjUm0yKmjtCTJhDSXZVEXvnc1RtQoLJzviQsSp6yDdHrA7UwZNBzgMQc3_ol7PUREYY3tLXTXs0_eA-XaJ_J0ONIk2xUnW4B_erXbjeA-UDXFg76BXSmq0CHmcmIewz__z7QI8W7XMS-p087h2mvgxHQFC9tOE2SKQl8oLHFKPm5QrViTs1vrH6sHSYfVoEnJ4XHtV4GPEU0gRco2aYF6x7lfM6I_FGDG0Xm1lncuZUxJ6ger9CF5KB0t881bJbnAvx3WdpPNPw23uG2CqqcadZ5phhvLhh7UDT_kmvq9p04w2E1OTRGxnpljA0qppfFIAAB9wcKdD7cJW48cYjoFTnxKxRaIJYATgquEQ7uzLXsmMu_JeWQpe7gjPlc0lTzguOYp5Rn0vLRxeYZhsN2rwO-g_9XBgZ5_smxUuVYLQeujJvJL41NwOkLtWHWe-r1B449P7Y2Y1uktbd0v5xDRPsde4MynOh3TJWUVw8S2bTP82giPHRryz3l3NRfMaxAJ-fgEggmJV7RNelOAnKYIXnNLA=w1124-h422-no\" alt=\"centered image\"  width=\"400\" height=\"200\">\n",
        "</p>\n",
        "\n",
        "> (source: https://cognitiveclass.ai/blog/nested-lists-multidimensional-numpy-arrays/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bJJJv6tHz0FA"
      },
      "source": [
        "각 원소에 1을 더하는 코드는 아래와 같습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NuyFbrDWyzRH",
        "outputId": "f31d17c0-c2d2-4bd8-d7dd-7b9e39d0764e"
      },
      "source": [
        "MathScoreNestedList2 = []\n",
        "\n",
        "for list in MathScoreNestedList:\n",
        "  tempList = []\n",
        "  \n",
        "  for e in list:\n",
        "    tempList.append(e+1)\n",
        "  \n",
        "  MathScoreNestedList2.append(tempList)\n",
        "  \n",
        "\n",
        "print(MathScoreNestedList2)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[12, 13, 14], [22, 23, 24], [32, 33, 34]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ggk9YaVCEeQk"
      },
      "source": [
        "#### 문제점\n",
        "\n",
        "1차원에서 2차원으로 데이터의 차원이 증가하니 반복문도 하나 더 사용해야 합니다.\n",
        "\n",
        "데이터의 차원이 증가할수록 코드는 복잡해질 수밖에 없습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KyRVZiGsX8-d"
      },
      "source": [
        "## NumPy로 구현한 다차원 배열"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VAJJqz6Gx-LD"
      },
      "source": [
        "**NumPy**를 사용하면 다차원배열을 효율적으로 다룰 수 있습니다.\n",
        "\n",
        "`import numpy as np` 형태로 import하는게 일반적입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oWA0-ULoyHe2",
        "outputId": "a4ccdd80-a518-4a3f-9dcf-a28c6afdffb0"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "mathScoreNdarray = np.array(MathScoreNestedList)\n",
        "# mathScoreNdarray = np.array([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
        "\n",
        "print(mathScoreNdarray)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12 13]\n",
            " [21 22 23]\n",
            " [31 32 33]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eBOJNzZzci-R",
        "outputId": "29d2a5ab-d5e1-427f-fb98-221ee947b0ff"
      },
      "source": [
        "mathScoreNdarray"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[11, 12, 13],\n",
              "       [21, 22, 23],\n",
              "       [31, 32, 33]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lgl_tzgkC7Zt"
      },
      "source": [
        "각 원소에 1을 더하려면"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d3fecKmbyjVJ",
        "outputId": "46a5f066-cf9c-4378-b9d8-d22fba84924e"
      },
      "source": [
        "mathScoreNdarray + 1 # 이것이 바로 브로드캐스팅! 후반부에 다룰 예정입니다."
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[12, 13, 14],\n",
              "       [22, 23, 24],\n",
              "       [32, 33, 34]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0tvgQrXOC-U9"
      },
      "source": [
        "NumPy에 구현된 메서드를 활용해 합이나 평균도 쉽게 구할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZSoke9ZuGTO9",
        "outputId": "a98a3a7c-bd2b-4ff7-c058-007a43f05c60"
      },
      "source": [
        "# 전체 합 구하기\n",
        "np.sum(mathScoreNdarray)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "198"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "io9nIHuLDAYn",
        "outputId": "3748d251-7fb5-4750-948b-be562120563e"
      },
      "source": [
        "# 전체 평균 구하기\n",
        "np.mean(mathScoreNdarray)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "22.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rmXOPrigDJQN"
      },
      "source": [
        "# 열의 평균 구하기\n",
        "np.mean(mathScoreNdarray, axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oi3vpqc9DJEL"
      },
      "source": [
        "# 행의 평균 구하기\n",
        "np.mean(mathScoreNdarray, axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WO1oIiOgX83Z"
      },
      "source": [
        "## 파이썬 기본 자료형과 넘파이 비교 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "id": "gTrzJCePGKG2"
      },
      "source": [
        "# 크기가 100개 이내인 경우 NumPy는 순수 파이썬 구현 보다도 오히려 낮은 성능을 보이는 경향이 있습니다.\n",
        "\n",
        "# rows ,cols가 2일떄 아래 타이머코드를 실행해 보고 rows, cols를 1000으로 바꾼 뒤 다시 코드를 실행 해 보세요.\n",
        "# 차이를 볼 수 있습니다.\n",
        "rows = 2  # 행\n",
        "cols = 2  # 열\n",
        "sampleRand2Darray = np.random.rand(rows, cols)  # ndarry 선언\n",
        "sampleRand2Dlist = sampleRand2Darray.tolist()   # nested list 선언"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O0q9eIhjGn7f",
        "outputId": "039126fc-f44b-4d7a-9baa-489a772c20d7"
      },
      "source": [
        "# rows, cols가 1000넘어갈땐 실행 하지 마세요. (노트북 멈춥니다.)\n",
        "sampleRand2Darray"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.66439853, 0.75525747],\n",
              "       [0.68938113, 0.47434604]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "34YB4XnRGnj2",
        "outputId": "2afc74b1-18a1-43b4-c430-6302cc6899bc"
      },
      "source": [
        "# rows, cols가 1000넘어갈땐 실행 하지 마세요. (노트북 멈춥니다.)\n",
        "sampleRand2Dlist"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[0.6643985288486859, 0.7552574725701711],\n",
              " [0.6893811258259187, 0.474346044836476]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C5afV1nFfowk"
      },
      "source": [
        "#### NumPy 장점\n",
        "\n",
        "- 코어 부분이 C로 구현되어 동일한 연산을 하더라도 Python에 비해 속도가 빠름\n",
        "- 라이브러리에 구현되어있는 함수들을 활용해 짧고 간결한 코드 작성 가능\n",
        "- (효율적인 메모리 사용이 가능하도록 구현됨)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UzwJlSsmPtTq"
      },
      "source": [
        "### (참고) ndarray가 list보다 빠른 이유"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEqzxKWIMXSv"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/JD1ljKEm4S_4hvIu8XqTLUw75AjB6K-ElhXY6oMqBiPVEPIkNpHjlMLKsTbpWMIXOZ1X3Ompb-v3lI5FHqlyWWOFR0Pg3vLsio9_8OSgFoAywjGAC6oY85kCahlx-rJtSqW9M3szyXBVjrnlUYIo3opwX7ch7BYaV6sLReXAOwcJThS4f-E-PQWOzwSsCerL_-QEi_wcEV_4Aef_q0u9lrcjvZX-OwW-AcSILKPIB3yoZar4zTTOPHz-miQ4yq2gOktHY1wR4izuJ5SmIT2feKEdP6sD5So8I24vdt1mKKjro3fQenb9ExtH-zAxlJQarxaDnklts7801rG56sa6sE69ZJBp3ZzJ8qr59SM1xf2t9dU1WHcIvMWM5g39B85aIYHRCFmqfwaAx6Gl8x7To_33nyLpc8hA6gIbPQ46O6N_I3-s2G_t5E1dt9mEr0v9fgnco5ib53RP7myVnH6prsSOP4n0hzSvf_gBvKsYIJ2TJA-631XcIR5K7VgE6kycjbVGtTlfDn5fTbVbjgJyIR2xhjPFQ85rxpLnPD0NLE8LzGzjA7bo3CJiBjd0CUHbjbUbUINtLHm8H8lT9U7vZIEzLSIA4dvO3SujTC8R8F7dPBO5Bc91VTWF1mqUftGeWmIdJ61E-KlKb6lRYnRdNq55scpLa3sX2Y2v3tCFq4uHvUM2VO4gkyi_9WNZciyoq1gQD8e9_Ig3aUsWdU87JJMQNw=w638-h479-no)\n",
        "\n",
        "> (source: https://image.slidesharecdn.com/numpy20160519-160516164831/95/numpy-8-638.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-w7yLTNSuMM"
      },
      "source": [
        "**파이썬 list가 느린 이유**\n",
        "\n",
        "- 파이썬 리스트는 결국 포인터의 배열\n",
        "- 경우에 따라서 각각 객체가 메모리 여기저기 흩어져 있음\n",
        "- 그러므로 캐시 활용이 어려움\n",
        "\n",
        "**NumPy ndarray가 빠른 이유**\n",
        "\n",
        "- ndarray는 타입을 명시하여 원소의 배열로 데이터를 유지\n",
        "- 다차원 데이터도 연속된 메모리 공간이 할당됨\n",
        "- 많은 연산이 dimensions과 strides를 잘 활용하면 효율적으로 가능\n",
        "  - 가령 transpose는 strides를 바꾸는 것으로 거의 공짜\n",
        "- ndarray 구현 방식을 떠올리면 어떻게 성능을 낼 수 있는지 상상 가능\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZvri5rGa9ky"
      },
      "source": [
        "- 예) NumPy에서 Transpose 구현"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tHcsagXmaore"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/-cTovEUtM3SZj9_Pd12Sf_hkJpwr9hvvlOTQVC80Q697w8bsSV7I4sAru5fHmgxU7FmxZtq9ZqgvOAqZg41oFjXaEwAtLMLVmN75BIk6HClFMfC6jecLYB6sKDWQUNcLDb2Pt5Vbi8jUVb6VLyWbZGvCVYobh1ev1aNvPoCrqBtR8uv1P8E99xSoaIvzp4dvVG14b_eLBGKuTnak0P305F8OgJgQq2M0Q8_unVPygZOo-vdA9fPx8z_LpOqB0ZIqIXEhf7NmsRWk0cuuUkgJlqJselVnHnTSIVCIohQaOLAU1U_Acufab3szF4BGP-D3DUUQaPcsN-HhxIkSEaFgxuylaRbEUOdYWeXwvuYe9tzNkIzndFtWaQ0MfeBbwlEscaIRVjxsICdCdT0xvX8vpgBegnNQUSo0kT2e3JjY3VLO8YQZ28W457BMyz_2NA_hKuwcGeFWotVoN0AlUTNNQSlpwQzitwSAsi_IlVfNDRYTTTFb-9dTjD9rdgQid3khyHmelE6k1VYayHnwJsJPiD_hcNGYpUChhC5WD-05Qg-R6vrOWXCvkB0tG4Q7fxMIh1_-fhOwEyEOsH91byk4afqJx559LeHldNiDVeU6I-rJRPtkG5mrBYPr0jD2uSIDvpX0ATVesWlunIKD7kvctEidPx8I7yhbKaI96L81K5cbGg49To2OpUaNZ3ttvZiztErvTbkLhruKXIj253HWAI2Jdg=w720-h405-no)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bo2JDzn3X5LZ"
      },
      "source": [
        "x = np.array([[1,2],[3,4]], dtype=np.int8)\n",
        "\n",
        "y = x.T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZpAtMh_X-Xd"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5JU0K-K2X95g"
      },
      "source": [
        "y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "46HZuKvGgCAE"
      },
      "source": [
        "print(x.strides)\n",
        "print(y.strides)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LdbiXqEKX8yr"
      },
      "source": [
        "# 다차원 배열 생성 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YqF37G0_hJn1"
      },
      "source": [
        "명시적으로 값을 입력해 다차원 배열을 만드는 방법을 알아봅니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h7VbFRMGYTU3"
      },
      "source": [
        "## 다차원 배열의 자료형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "csIZ1CsL73Vj"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/ZhC-hkgaa_zQggBdbQ8J33aW8b6Ubbccwr4dLOiVlXAuJYgBiZzRR0jcrAe9C6h26h_3xfd1UbMt6vwIpLfDffABXNKDkUT6RUZre4-j7DtYt7CFsQ1b4RdNZwfCQoSkr_BWKACQQ42krqB0Jkri4CDHGMhKgALRRiJJaQCsR0frysFtltqxiX0ScqZleBxMkADkJr8FtFKh34ERS4w3lwIqddpWd9ctgu9bJsDA19yNEmLouiwapSV7NwAXgDko3fqxo_W4CY6NU_vXxx8xoyFtaXxdXRCs2yketYJ66IP8Rv_mADUSnXfcCfgHOPlU_PzkT-cLdnfLftHgitAPrDHOqiH7EpLmgg4bO_HWIhpDwfG7iu2upN_rw-sFl64aGj4XhhbPYfmDZpnIEyrvKE4DjycH6rITqxTbhMSWfkeeUBENLusqELkVnPRikaaxYiDVPRuedOp6hNXo7R4A-TghyLn-k61kV3Ruwc14ytOWhZ0BngaDXVo-KF_ZxJUr5GuaFOZbi4UKhXbvnObRZAb0QgKaCdvkYysxU31oryDHpx526hG6SW6b99CxOWbT0lBTy0RoynGz_WVV_ua_umNcmkBNMkt3u04uCUWk8a-BqMG_oVpyqNmqetASSOhCZNbisBzkEgmo4sDbdqsNlFcY3fa-Og8mB1UNmC2uWl5RefSArRAoKn6KxZpcr6qJdl8YWT98ncW6behEO1wLoNsdBg=w526-h413-no)\n",
        "\n",
        "(source: https://docs.scipy.org/doc/numpy/reference/arrays.scalars.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klF_e3KW9Vpx"
      },
      "source": [
        "다차원 배열의 원소는 위와 같은 데이터 타입을 가질 수 있습니다.\n",
        "\n",
        "다차원 배열의 원소는 동일한 데이터 타입을 가져야 합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T0lV8kuGYTkg"
      },
      "source": [
        "## 직접 원소를 입력해서 다차원 배열 생성하기"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NpxbG2gDGnA"
      },
      "source": [
        "**np.array()**를 사용해 다차원 배열을 생성할 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MWPPYiNFBuJa"
      },
      "source": [
        "### bool"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ppE0ijaUC6x5"
      },
      "source": [
        "boolean 데이터를 입력해서 다차원 배열을 생성해봅시다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_a7cfM8aBiaf"
      },
      "source": [
        "boolArray = np.array([True, False, True, True, False])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o8vfhrvL8o4l"
      },
      "source": [
        "boolArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cakQ3-2HBp54"
      },
      "source": [
        "boolArray.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SPopJWaXBxOP"
      },
      "source": [
        "### number"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W1vU7-rxDqZi"
      },
      "source": [
        "number 데이터를 입력해서 다차원 배열을 생성해봅시다.\n",
        "\n",
        "정수형, 부호없는 정수형, 실수형, 복소수형이 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCNgKGDuCJSM"
      },
      "source": [
        "#### 정수형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "riYQenZzEUt_"
      },
      "source": [
        "정수형의 default data type은 'int64'입니다.\n",
        "\n",
        "<font color=\"red\">(진실: default data type은 운영체제에 따라 다릅니다.)</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QPVhK1XvB6sH"
      },
      "source": [
        "intArray = np.array([[1, 2], [3, 4]])"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_0m-Jv15B_ha",
        "outputId": "aa5b1c53-edfd-4196-b8fa-4efc1c03e89a"
      },
      "source": [
        "intArray"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [3, 4]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XynD9eUOB_Zf",
        "outputId": "43ad6d2c-b680-41f2-8a6e-a1bb1c7872dc"
      },
      "source": [
        "intArray.dtype"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dtype('int64')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6ZENZr82D1jh"
      },
      "source": [
        "#### 부호없는 정수형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9-eWQM6JEY48"
      },
      "source": [
        "부호없는 정수형의 default data type은 'uint64'입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9xYaFEmMD39n"
      },
      "source": [
        "uintArray = np.array([[1, 2], [3, 4]], dtype='uint')\n",
        "# uintArray = np.array([[1, 2], [3, 4]], dtype='uint64')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "COosTXN_EBiR"
      },
      "source": [
        "uintArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_y00GptXEBOm"
      },
      "source": [
        "uintArray.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9H0yDDqMB0fu"
      },
      "source": [
        "#### 실수형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efVd88hfEjFr"
      },
      "source": [
        "실수형의 default data type은 'float64'입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZlMmubOcCQbV"
      },
      "source": [
        "floatArray = np.array([[1.1, 2.2], [3.3, 4.4]])\n",
        "floatArray = np.array([[1.1, 2.2], [3.3, 4.4]], dtype='float64')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Yi94xAtCQYJ"
      },
      "source": [
        "floatArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IME-bubKCQTA"
      },
      "source": [
        "floatArray.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DWSVrft6IXv_"
      },
      "source": [
        "##### 형변환"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WLO7UIQGEras"
      },
      "source": [
        "데이터가 정수로 입력되더라도 data type을 실수형으로 명시한다면 실수형으로 자동 형변환이 일어납니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HIOBnBfECg_h"
      },
      "source": [
        "floatArray2 = np.array([[1, 2], [3, 4]], dtype='float64')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TIs7n0qTCg8o"
      },
      "source": [
        "floatArray2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5R-yc4IHCg4K"
      },
      "source": [
        "floatArray2.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ac-kL0GrIJXT"
      },
      "source": [
        "##### 더 나은 방법"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YOXJ-BHNI0WF"
      },
      "source": [
        "1.0, 2.0, 3.0, 4.0이라는 실수형 데이터를 가지는 다차원배열을 만들고 싶었다면, 아래 방법이 더 나은 코딩표준입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4TRVN90hH-Q0"
      },
      "source": [
        "floatArray3 = np.array([[1., 2.], [3., 4.]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t_EosM17IDgy"
      },
      "source": [
        "floatArray3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sfln3jgRIDWI"
      },
      "source": [
        "floatArray3.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dQT7fOIGG0Np"
      },
      "source": [
        "##### 참고"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GgSv92NxH0Lp"
      },
      "source": [
        "정수형에서 실수형으로의 형변환 과정은 데이터 손실이 일어나지 않아 문제될 부분이 없지만 반대의 경우에는 문제가 발생할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OyI5R0pKHLjG"
      },
      "source": [
        "intArray2 = np.array([[1.1, 2.2], [3.3, 4.4]], dtype='int')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0rqDle1lHSjP"
      },
      "source": [
        "intArray2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2w0QOfD3Igzv"
      },
      "source": [
        "실수가 정수로 형변환되며 데이터의 손실이 발생했습니다.\n",
        "<font color=\"red\">입력한 데이터와 다차원 배열내의 데이터가 다릅니다.</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LbE2qHLjB0O9"
      },
      "source": [
        "#### (참고) 복소수형"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wkKPYQREGH40"
      },
      "source": [
        "복소수형의 default data type은 'complex128'입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8YHs9hemF42o"
      },
      "source": [
        "complexArray = np.array([1+1j, 2+2j, 3+3j, 4+4j, 5+5j])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JhWPA4DI53Eq"
      },
      "source": [
        "complexArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfF1aCfQGCw3"
      },
      "source": [
        "complexArray.dtype"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-FJY7VRbYTuR"
      },
      "source": [
        "## 파일에서 데이터를 입력 받아 다차원 배열 생성하기\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3HdL2XcfTbAO"
      },
      "source": [
        "np.genfromtxt()을 이용하여 파일에 저장된 데이터를 입력받아 다차원 배열을 생성할 수 있습니다.\n",
        "\n",
        "하지만 사용할 일은 많지 않습니다. 그 이유는,\n",
        "\n",
        "- NumPy ndarray는 동일한 데이터타입만을 가질 수 있습니다.\n",
        "- 대부분 데이터 파일에는 하나의 데이터 타입만 있는게 아니라 정수, 실수, 문자열이 섞여 있습니다.\n",
        "\n",
        "파일에서 데이터를 읽어올땐 NumPy의 genfromtxt()보단 **Pandas의 read_csv()나 read_excel()**을 주로 사용합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87ZULGqjNVo9"
      },
      "source": [
        "### 예시"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s3dNZLWiMfMj"
      },
      "source": [
        "# 파일 다운로드 받기\n",
        "!wget -O 'mnist_train_super_small.csv' https://docs.google.com/spreadsheets/d/1lUBHgDlG5EVoZxfSF84X5jbcyynjnWSK8_weiQApt2M/export?format=csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tyGFs4eANb5f"
      },
      "source": [
        "import numpy as np\n",
        "fromCSVArray = np.genfromtxt('mnist_train_super_small.csv', delimiter=',')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJV40k7tNbyA"
      },
      "source": [
        "fromCSVArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D6Oz2Ld0NQPW"
      },
      "source": [
        "### 구글 드라이브에서 파일 가져오기"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HXF0Vl0pKNar"
      },
      "source": [
        "# 구글드라이브의 파일을 가져오고 싶은 경우\n",
        "\n",
        "# 구글드라이브 마운트\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c5AgQYcnKjkM"
      },
      "source": [
        "# 구글드라이브내에 있는 파일 경로 지정\n",
        "fromCSVArray = np.genfromtxt('/content/drive/My Drive/talk-on-seminar-numpy/resources/mnist_train_super_small.csv', delimiter=',')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BqJXtoaAvISo"
      },
      "source": [
        "fromCSVArray"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6FWAdVaYT1a"
      },
      "source": [
        "# 다차원 배열 생성 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-nIkZ9IS9AAI"
      },
      "source": [
        "NumPy에 구현되어있는 함수를 활용해 다차원 배열을 만드는 방법을 알아봅니다.\n",
        "\n",
        "https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOPgfIGmYT89"
      },
      "source": [
        "## numpy.empty"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cXi-LLekg6pC"
      },
      "source": [
        "Return a new array of given shape and type, without initializing entries."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FfORCLsWgd39"
      },
      "source": [
        "np.empty((4,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ZeJainFhFeO"
      },
      "source": [
        "A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZM3ofgHfd8ie"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pv64IqQMhUdi"
      },
      "source": [
        "np.empty_like(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3SQd-8BcYT6O"
      },
      "source": [
        "## numpy.zeros"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PKH0lUxriSA6"
      },
      "source": [
        "Return a new array of given shape and type, filled with zeros."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJEqvi2tiScc"
      },
      "source": [
        "np.zeros((2, 3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBAZ2cC9ieG9"
      },
      "source": [
        "np.zeros((2, 3), dtype=int)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bxdxGvAshgGS"
      },
      "source": [
        "np.zeros_like(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2f6I3TUUYT--"
      },
      "source": [
        "## numpy.ones"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2TtCx78Gf_Gu"
      },
      "source": [
        "Return a new array of given shape and type, filled with ones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "51_LeiXcfpzR"
      },
      "source": [
        "np.ones((2,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4OqSJJs7hwbQ"
      },
      "source": [
        "np.ones((2,3), dtype=int)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FFIxgrN9hzSn"
      },
      "source": [
        "np.ones_like(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iYHi8SL9jHdR"
      },
      "source": [
        "## numpy.identity"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wppdmiYnjLVS"
      },
      "source": [
        "Return the identity array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gk5ptfwOjMoM"
      },
      "source": [
        "np.identity(2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ufzLDxObjMbQ"
      },
      "source": [
        "np.identity(3, dtype=int)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EphARzOujW1z"
      },
      "source": [
        "## 참고"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i-hkaJr0iG1v"
      },
      "source": [
        "### numpy.eye"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AqDYqxoIiU1x"
      },
      "source": [
        "Return a 2-D array with ones on the diagonal and zeros elsewhere."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OMBY4vpth2fA"
      },
      "source": [
        "np.eye(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RvJUTBkyh2Nr"
      },
      "source": [
        "np.eye(3, 4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yoB2BTKOiyvB"
      },
      "source": [
        "np.eye(3, 4, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q5wD8DWRjuDs"
      },
      "source": [
        "np.eye(3, 4, -1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o2-dCEXxkAsq"
      },
      "source": [
        "### numpy.full"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HlqXmw0rkHNn"
      },
      "source": [
        "numpy.full(shape, fill_value, dtype=None, order='C')\n",
        "\n",
        "Return a new array of given shape and type, filled with fill_value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "geBFyWUEkG25"
      },
      "source": [
        "np.full((2, 3), 10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CnCSOJICkVjv"
      },
      "source": [
        "위 보다는 아래 방식을 선호합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B3n5nkYgkPT3"
      },
      "source": [
        "10 * np.ones((2,3), dtype=int)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AdnkzqaLfk7O"
      },
      "source": [
        "### numpy.arange"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xgmdzhZPhOZs"
      },
      "source": [
        "Return evenly spaced values within a given interval."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Sr383Cmfkd7"
      },
      "source": [
        "# default value\n",
        "# start = 0\n",
        "# step = 1\n",
        "np.arange(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n0rm-lH7gSmd"
      },
      "source": [
        "np.arange(start=1.0, stop=5.0, step=0.5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vj0WRG9-hbd4"
      },
      "source": [
        "### numpy.linspace"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "azYRu3ophbRq"
      },
      "source": [
        "Return evenly spaced numbers over a specified interval."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AfShQksbhku-"
      },
      "source": [
        "np.linspace(2.0, 3.0, num=5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8umKaPA-YT4J"
      },
      "source": [
        "# 다차원 배열 다루기 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YJamUKL9nK3T"
      },
      "source": [
        "통계값을 구하는 함수에 대해 알아봅니다.\n",
        "\n",
        "<font color=\"red\">이제 반복문은 사용하지 않습니다.</font>\n",
        "\n",
        "https://docs.scipy.org/doc/numpy/reference/routines.statistics.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_Ha7m_6oaVw"
      },
      "source": [
        "![alt text](https://lh3.googleusercontent.com/zXC7mbgObMUkQoUnkfMvog5wU8Qh2bvLEwINZo7eilDpq_aun8c3D_qCvaCZhQQLnC-iz7XxFP3iWylf3RZWNsKUaw2MFU0c4Oiu3cbZIPM4AsgSSUVYlDzZKVgG-ldbaEt2vty-cqaHNqrIYNPjsN6n8gT5XbJPqEk5GJjjTfL61t5ugfaDtHjbskwoZm45x8xbWJgkilc8fZ70hWGr8tpskk_5P4G3dI9zy0-ZNTDF9R2nGknAjcmCT3cP5nKhL0YM8mhhbWxS7jTotR1A-hKBPRXbu-5tFa1W54F8k4Do17Wvhz_JNaj0EX-5z0BT8ryE6XPvsJd4vlQAAzwYKdy9oIL7KYzTiIy3vi7MicCg7opIc87ueczPBpZUv2vczrUzzOT-6Yczc9Ay2UPvzyS6SmB2QJI2gGXXvdRFZAElecn83X98psuIHAGx7xii7OplLOQLNaDN3o0tCt4v0e2mgnP8zU87MfUGMCgs-zJwCZYeJz-2rt1EHGGk0IuiiDJQ-R_X91KUE1Z76VOHOjBt_saj-UJ40dTB2w_ITArQa1dH2GhPZCz7wC4_UmwYlr1BHUiohA1ByDBHRB2cA8sBF5MU3s7F1KKWPQUcBQqf2NhQgUJTYWnvWUrgqdmvEKRVRiXwqlJiwGVc1_nCFUAOtzXqLtJAvT0mlKso-GUEPy6NPFjR-Yvv4ci_QFfhtUh87MyVYTEphY7xcNwTaswPqw=w652-h341-no)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WeQkeSp9YTxA"
      },
      "source": [
        "## numpy.amin"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tr0WYF7Co1ho"
      },
      "source": [
        "Return the minimum of an array or minimum along an axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-Ptumyjo0dT"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "et4d4RNIocCs"
      },
      "source": [
        "#np.amin(A, 0)\n",
        "np.amin(A, axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0jLWkPjdoyrB"
      },
      "source": [
        "np.amin(A, 1)\n",
        "# np.amin(A, axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QBbjFJ6GpDCn"
      },
      "source": [
        "np.amin(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gMsPpdw1pCWC"
      },
      "source": [
        "## numpy.amax"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fqn9ZjeRpUgO"
      },
      "source": [
        "Return the maximum of an array or maximum along an axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAootx86qA5z"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ej2Se2iXpJpQ"
      },
      "source": [
        "np.amax(A, 0)\n",
        "# np.amax(A, axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9sIDnzytpJna"
      },
      "source": [
        "np.amax(A, 1)\n",
        "# np.amax(A, axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CL6YZbXSolnf"
      },
      "source": [
        "np.amax(A, 1).shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XKrEdPH1pJQj"
      },
      "source": [
        "np.amax(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yVHIj1Iupnhf"
      },
      "source": [
        "## numpy.ptp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EFYuiVX4pxvj"
      },
      "source": [
        "Range of values (maximum - minimum) along an axis.\n",
        "\n",
        "The name of the function comes from the acronym for ‘peak to peak’."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8VxGXuinp8kQ"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q6YNHrwOpzuZ"
      },
      "source": [
        "np.ptp(A, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xm14LIGdp6a3"
      },
      "source": [
        "np.ptp(A, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z4QFXCVxp99u"
      },
      "source": [
        "np.ptp(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FoCO6OmSqUhW"
      },
      "source": [
        "## numpy.median"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-Eyf72Urhjz"
      },
      "source": [
        "Compute the median along the specified axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bi64JNDerJ7W"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ps-6IJLxrLTI"
      },
      "source": [
        "np.median(A, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hsVht0ByrQN1"
      },
      "source": [
        "np.median(A, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SsqQsYZ1rU_N"
      },
      "source": [
        "np.median(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OBi1rF4uqYaW"
      },
      "source": [
        "## numpy.mean"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fxwp6vDBr0uO"
      },
      "source": [
        "Compute the arithmetic mean along the specified axis.\n",
        "\n",
        "(가중평균을 구하려면 numpy.average를 사용해야 합니다.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sbY1nmGHseNT"
      },
      "source": [
        "A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WnFfddIZrdsT"
      },
      "source": [
        "np.mean(A, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tNyK0HGXrdNp"
      },
      "source": [
        "np.mean(A, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n79iGG5jrc1M"
      },
      "source": [
        "np.mean(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QtXO6zuuqYVa"
      },
      "source": [
        "## numpy.var"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wPXmUNHmsxrp"
      },
      "source": [
        "Compute the variance along the specified axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dSSXxSv7s_S0"
      },
      "source": [
        "np.var(A, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0NMEX8w5s-6a"
      },
      "source": [
        "np.var(A, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LxQSe0JoqX5I"
      },
      "source": [
        "np.var(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5s-Mj7H8tEUR"
      },
      "source": [
        "## numpy.std"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "enWqlt2rtHjV"
      },
      "source": [
        "Compute the standard deviation along the specified axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kgMKCi3MtKdT"
      },
      "source": [
        "np.std(A, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Rm1-Cq0tKKM"
      },
      "source": [
        "np.std(A, 1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yIfc_SX2tKEq"
      },
      "source": [
        "np.std(A)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DAql9fTuYTr_"
      },
      "source": [
        "# 다차원 배열 다루기 2\n",
        "다차원 배열에서 일부분만 가져오거나 다차원 배열의 형태를 바꾸는 방법을 알아봅니다.\n",
        "\n",
        "https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YJOXeenmYTni"
      },
      "source": [
        "## 슬라이싱"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UrUs0eyi12sY"
      },
      "source": [
        "파이썬 리스트와 유사하게, Numpy 배열도 슬라이싱이 가능합니다.\n",
        "\n",
        "Numpy 배열은 다차원인 경우가 많기에, 각 차원별로 어떻게 슬라이스할건지 명확히 해야 합니다:\n",
        "\n",
        "Numpy 배열을 슬라이싱하면, 연속된 값을 가져오기에 결과로 얻어지는 배열은 언제나 원본 배열의 부분 배열입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rSTklt9WuQj5"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# shape가 (3, 4)인 2차원 배열 생성\n",
        "# [[ 1  2  3  4]\n",
        "#  [ 5  6  7  8]\n",
        "#  [ 9 10 11 12]]\n",
        "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gvAMJaf9vPa7"
      },
      "source": [
        "다차원배열은 아래와 같은 방법으로 슬라이싱 합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "osPEARhNvmFf"
      },
      "source": [
        "`a[ : , : ]`\n",
        "\n",
        "\n",
        "`a[행 슬라이싱 시작:행 슬라이싱 끝, 열 슬라이싱 시작:열 슬라이싱 끝]`\n",
        "\n",
        "\n",
        "**시작값**부터 **끝값** <font color=\"red\">전</font>까지 슬라이싱 됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s6MPTZG2wmRW"
      },
      "source": [
        "a[0:2, 0:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1tA0TY58wrjf"
      },
      "source": [
        "0행부터 2행 전까지(= 1행 까지), 0열부터 4열 전까지(= 3열 까지) 슬라이스되었습니다.\n",
        "\n",
        "시작값이 0인 경우 생략 가능하며 끝 값이 shape의 값과 동일한 경우 생략 가능합니다.\n",
        "\n",
        "`a[0:2, 0:4]`은 `a[:2, :]`로 표시할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sBVcKEPCwmNd"
      },
      "source": [
        "a[:2, :]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "He-aVrqQ3eBA"
      },
      "source": [
        "위 코드는 열을 슬라이싱 하지 않는 코드이며 이런 경우 열 부분은 전체 생략 가능합니다.\n",
        "\n",
        "(행을 슬라이싱 하지 않는다고 하더라도, 행부분을 생략할 순 없습니다.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b7EOJsdkwmKb"
      },
      "source": [
        "a[:2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DFoCzNO4dRr"
      },
      "source": [
        "**슬라이싱에 익숙해지기 전까진 생략하지말고 명시적으로 코드를 작성해주는것이 실수를 방지하는 방법입니다.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1fcIHf654TM"
      },
      "source": [
        "## 인덱싱"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzL4Xo-N6b4k"
      },
      "source": [
        "인덱싱을 통해 원소에 접근할 수 있습니다.\n",
        "\n",
        "두 가지 표현법이 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6P16QmWU6gLp"
      },
      "source": [
        "# 선호하는 방식\n",
        "a[0, 0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wTKkLKLS6VTf"
      },
      "source": [
        "a[0][0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mO7ZPlga57Yd"
      },
      "source": [
        "Numpy 배열을 슬라이싱하면, 연속된 값을 가져오기에 결과로 얻어지는 배열은 언제나 원본 배열의 부분 배열입니다.\n",
        "\n",
        "그러나 인덱싱을 한다면, 연속하지 않은 값을 가져올 수 있으니 원본과 다른 배열을 만들 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ajcFwt7b9G_Z"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MX-MxYDl8eWr"
      },
      "source": [
        "# 0행, 2행만 인덱싱\n",
        "a[[0, 2], ]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4F_hYGty9Vag"
      },
      "source": [
        "# 0열, 1열, 3열만 인덱싱\n",
        "a[:, [0,1,3]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nKciLNy_RLI5"
      },
      "source": [
        "## 인덱싱&슬라이싱 - 차원"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QAObDpXdRQPQ"
      },
      "source": [
        "정수 인덱싱과 슬라이싱을 혼합해서 사용하면 낮은 차원의 배열이 생성되지만,\n",
        "\n",
        "슬라이싱만 사용하면 원본 배열과 동일한 차원의 배열이 생성됩니다.\n",
        "\n",
        "0번째 행을 인덱싱하는 경우와 슬라이싱 하는 경우를 비교해보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OFo3Mmd4RP3w"
      },
      "source": [
        "print(a, a.shape, a.ndim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qIZ1PgyySLVK"
      },
      "source": [
        "# 슬라이싱만 사용\n",
        "slicedRow = a[0:1, :]\n",
        "print(slicedRow, slicedRow.shape, slicedRow.ndim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ost9l4B1R8tw"
      },
      "source": [
        "# 아래와 동일한 코드\n",
        "# 인덱싱&슬라이싱 혼합 사용\n",
        "indexedRow = a[0]\n",
        "print(indexedRow, indexedRow.shape, indexedRow.ndim)\n",
        "\n",
        "# 위와 동일한 코드\n",
        "# 인덱싱&슬라이싱 혼합 사용\n",
        "indexedRow2 = a[0, :]\n",
        "print(indexedRow2, indexedRow2.shape, indexedRow2.ndim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OWuj2vu3TK6y"
      },
      "source": [
        "행이 아닌 열의 경우에도 마찬가지 입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZcXhWBMTSERz"
      },
      "source": [
        "# 슬라이싱만 사용\n",
        "slicedCol = a[:, 0:1]\n",
        "print(slicedCol, slicedCol.shape, slicedCol.ndim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y09IJ9mFU4ct"
      },
      "source": [
        "# 인덱싱&슬라이싱 혼합 사용\n",
        "indexedCol = a[:, 0]\n",
        "print(indexedCol, indexedCol.shape, indexedCol.ndim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6AFtk8WmVbfc"
      },
      "source": [
        "다차원배열간 연산에서 차원이 달라 문제가 발생하는 경우가 종종 있습니다.\n",
        "\n",
        "**특별히 인덱싱을 써야 하는 상황이 아니라면, 인덱싱보다 슬라이싱을 추천합니다.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2eLKR9auQK7m"
      },
      "source": [
        "## 인덱싱&슬라이싱 - 값 복사&참조"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SQGaAAhFQQLx"
      },
      "source": [
        "인덱싱은 값을 복사해옵니다. 복사된 값을 변경해도 원본의 값은 변하지 않습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6__bo0VQQYmY"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4xtsM0d7P37t"
      },
      "source": [
        "# 인덱싱해서 b에 대입\n",
        "b = a[0, 0]\n",
        "\n",
        "# b값 수정\n",
        "b = 100\n",
        "\n",
        "print(\"a[0, 0]: {}\".format(a[0, 0]))\n",
        "print(\"b: {}\".format(b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_JGPVOvtQ0gK"
      },
      "source": [
        "슬라이싱된 배열은 원본 배열과 같은 데이터를 참조합니다.\n",
        "\n",
        "<font color=\"red\">즉 슬라이싱된 배열을 수정하면 원본 배열 역시 수정됩니다.</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqVFNX_zQAha"
      },
      "source": [
        "# a를 슬라이스하여 c 생성\n",
        "c = a[1:3, 1:3]\n",
        "\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sn84SoasQEbx"
      },
      "source": [
        "# c[0, 0]은 a[1, 1]과 같은 데이터입니다.\n",
        "c[0, 0] = 100\n",
        "\n",
        "print(c)\n",
        "print('------------------')\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8HQJpEQA2wj2"
      },
      "source": [
        "## 불리언 배열 인덱싱"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPR4ewXDaJaT"
      },
      "source": [
        "불리언 배열 인덱싱을 통해 배열 속 요소를 취사선택할 수 있습니다. 불리언 배열 인덱싱은 특정 조건을 만족하게 하는 요소만 선택하고자 할 때 자주 사용됩니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4xl1Vbz2y71"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([[1,2], [3, 4], [5, 6]])\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2caKbkRbbzVD"
      },
      "source": [
        "bool_idx = (a > 2)  # 2보다 큰 a의 요소를 찾습니다;\n",
        "                    # 이 코드는 a와 shape가 같고 불리언 자료형을 요소로 하는 numpy 배열을 반환합니다,\n",
        "                    # bool_idx의 각 요소는 동일한 위치에 있는 a의\n",
        "                    # 요소가 2보다 큰지를 말해줍니다.\n",
        "\n",
        "print(bool_idx)      # 출력 \"[[False False]\n",
        "                     #       [ True  True]\n",
        "                     #       [ True  True]]\"\n",
        "\n",
        "# 불리언 배열 인덱싱을 통해 bool_idx에서\n",
        "# 참 값을 가지는 요소로 구성되는\n",
        "# rank 1인 배열을 구성할 수 있습니다.\n",
        "print(a[bool_idx])  # 출력 \"[3 4 5 6]\"\n",
        "\n",
        "# 위에서 한 모든것을 한 문장으로 할 수 있습니다:\n",
        "print(a[a > 2])     # 출력 \"[3 4 5 6]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orsL9GWLYTpQ"
      },
      "source": [
        "## (참조) 정수 배열 인덱싱"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gmXzZ-IyxESh"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([[1,2], [3, 4], [5, 6]])\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OBq04jLFZRGn"
      },
      "source": [
        "# 정수 배열 인덱싱의 예.\n",
        "# 반환되는 배열의 shape는 (3,)\n",
        "print(a[[0, 1, 2], [0, 1, 0]])  # 출력 \"[1 4 5]\"\n",
        "\n",
        "# 위에서 본 정수 배열 인덱싱 예제는 다음과 동일합니다:\n",
        "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  # 출력 \"[1 4 5]\"\n",
        "\n",
        "# 정수 배열 인덱싱을 사용할 때,\n",
        "# 원본 배열의 같은 요소를 재사용할 수 있습니다:\n",
        "print(a[[0, 0], [1, 1]])  # 출력 \"[2 2]\"\n",
        "\n",
        "# 위 예제는 다음과 동일합니다\n",
        "print(np.array([a[0, 1], a[0, 1]]))  # 출력 \"[2 2]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p3t9TzIMX5bG"
      },
      "source": [
        "## 전치(transpose)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zFtuErBr3lN0"
      },
      "source": [
        "종종 배열의 모양을 바꾸거나 데이터를 처리해야 할 때가 있습니다. 가장 간단한 예는 행렬의 주 대각선을 기준으로 대칭되는 요소끼리 뒤바꾸는 것입니다; \n",
        "\n",
        "이를 전치라고 하며 행렬을 전치하기 위해선, 간단하게 배열 객체의 ‘T’ 속성을 사용하면 됩니다:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BpMXJuMb3nti"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.array([[1,2], [3,4]])\n",
        "print(x)    # 출력 \"[[1 2]\n",
        "            #       [3 4]]\"\n",
        "print(x.T)  # 출력 \"[[1 3]\n",
        "            #       [2 4]]\"\n",
        "\n",
        "# 차원이 1인 배열을 전치할 경우 아무 일도 일어나지 않습니다:\n",
        "v = np.array([1,2,3])\n",
        "print(v)    # 출력 \"[1 2 3]\"\n",
        "print(v.T)  # 출력 \"[1 2 3]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PLZ_crwrYmvQ"
      },
      "source": [
        "## Shape 변경"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aflbVOpd708-"
      },
      "source": [
        "### numpy.reshape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XCMTsEvP7273"
      },
      "source": [
        "Gives a new shape to an array without changing its data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t8dR7iPqwgzA"
      },
      "source": [
        "np.arange(6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZabiDuswjzb"
      },
      "source": [
        "np.arange(6).reshape((3, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C5D6ux9P8ACt"
      },
      "source": [
        "a = np.arange(6).reshape((3, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DLBAyj0K8Jgk"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VCg8dOLG5JC1"
      },
      "source": [
        "np.reshape(a, (2,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dz_ffZkx5q-_"
      },
      "source": [
        "# 2차원\n",
        "np.reshape(a, (1,6))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8lVoSmog5qkf"
      },
      "source": [
        "# 1차원\n",
        "np.reshape(a, 6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWmGFdPN8sHz"
      },
      "source": [
        "### numpy.ravel()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "spkzJmkO80L6"
      },
      "source": [
        "Return a contiguous flattened array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzmcXTCq5qaH"
      },
      "source": [
        "np.ravel(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qbsqbAJZ53jX"
      },
      "source": [
        "a.ravel()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YZHKRyvk89wK"
      },
      "source": [
        "### numpy.ndarray.flatten()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5aABNEj89ERE"
      },
      "source": [
        "Return a copy of the array collapsed into one dimension."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V3IjMMqZ5Og5"
      },
      "source": [
        "# np.flatten(a) # Numpy 모듈 함수가 아님\n",
        "a.flatten()     # ndarray 객체의 메소드로만 사용 가능"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZvKr7dS_MxT"
      },
      "source": [
        "**ravel()과 flatten() 차이점**\n",
        "- flatten은 객체의 매소드로만 사용 가능\n",
        "- ravel()은 뷰를 반환, flatten은 복사본을 반환"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-e2xFxz9Ym87"
      },
      "source": [
        "## 연결"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tHanj3jX37oT"
      },
      "source": [
        "### numpy.concatenate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O67AqHaB3qqK"
      },
      "source": [
        "a = np.array([[1, 2], [3, 4]])\n",
        "b = np.array([[5, 6]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mvr_CL7C4EjK"
      },
      "source": [
        "np.concatenate((a, b), axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bMkQiBU0ySuX"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ffqEvbSqyUM9"
      },
      "source": [
        "a[0:1].T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YwrtBYd54EUw"
      },
      "source": [
        "np.concatenate((a, b.T), axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rVREocA94NhK"
      },
      "source": [
        "### 참조"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d0JgPbk903Pi"
      },
      "source": [
        "https://docs.scipy.org/doc/numpy/reference/routines.array-manipulation.html#joining-arrays"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NEfhcSP6Ym6r"
      },
      "source": [
        "# 다차원 배열 연산"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPREx67Z3B9K"
      },
      "source": [
        "기본적인 수학함수는 배열의 각 요소별로 동작하며 연산자를 통해 동작하거나 numpy 함수모듈을 통해 동작합니다.\n",
        "\n",
        "다차원 배열간 연산시, **shape가 맞아야** 연산이 이루어집니다.\n",
        "- 요소별 합, 차, 곱, 나눗셈의 경우 shape가 일치해야 합니다.\n",
        "- dot의 경우 앞 배열의 열과 뒤 배열의 행의 크기가 일치해야 합니다.\n",
        "\n",
        "https://docs.scipy.org/doc/numpy/reference/routines.math.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KB6qg3SB3Bde"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.array([[1., 2.], [3., 4.]])\n",
        "y = np.array([[5., 6.], [7., 8.]])\n",
        "\n",
        "# 요소별 합; 둘 다 다음의 배열을 만듭니다\n",
        "# [[ 6.0  8.0]\n",
        "#  [10.0 12.0]]\n",
        "print(x + y)\n",
        "print(np.add(x, y))\n",
        "\n",
        "# 요소별 차; 둘 다 다음의 배열을 만듭니다\n",
        "# [[-4.0 -4.0]\n",
        "#  [-4.0 -4.0]]\n",
        "print(x - y)\n",
        "print(np.subtract(x, y))\n",
        "\n",
        "# 요소별 곱; 둘 다 다음의 배열을 만듭니다\n",
        "# [[ 5.0 12.0]\n",
        "#  [21.0 32.0]]\n",
        "print(x * y)\n",
        "print(np.multiply(x, y))\n",
        "\n",
        "# 요소별 나눗셈; 둘 다 다음의 배열을 만듭니다\n",
        "# [[ 0.2         0.33333333]\n",
        "#  [ 0.42857143  0.5       ]]\n",
        "print(x / y)\n",
        "print(np.divide(x, y))\n",
        "\n",
        "# 요소별 제곱근; 다음의 배열을 만듭니다\n",
        "# [[ 1.          1.41421356]\n",
        "#  [ 1.73205081  2.        ]]\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dB_z-c6e3VOk"
      },
      "source": [
        "Numpy에선 벡터의 내적, 벡터와 행렬의 곱, 행렬곱을 위해 `*`대신 `dot`함수를 사용합니다.\n",
        "\n",
        "`dot`은 Numpy 모듈 함수로서도 배열 객체의 메소드로서도 이용 가능한 합수입니다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PFt0rCE3Y_M"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "x = np.array([[1,2],[3,4]])\n",
        "y = np.array([[5,6],[7,8]])\n",
        "\n",
        "v = np.array([9,10])\n",
        "w = np.array([11, 12])\n",
        "\n",
        "# 벡터의 내적; 둘 다 결과는 219\n",
        "print(v.dot(w))\n",
        "print(np.dot(v, w))\n",
        "\n",
        "# 행렬과 벡터의 곱; 둘 다 결과는 dimension 1인 배열 [29 67]\n",
        "print(x.dot(v))\n",
        "print(np.dot(x, v))\n",
        "\n",
        "# 행렬곱; 둘 다 결과는 dimension 2인 배열\n",
        "# [[19 22]\n",
        "#  [43 50]]\n",
        "print(x.dot(y))\n",
        "print(np.dot(x, y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FlyVDye2Ymo7"
      },
      "source": [
        "# NumPy 고급 기능"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "clp8mtKH35Sm"
      },
      "source": [
        "브로트캐스팅은 Numpy에서 shape가 다른 배열 간에도 산술 연산이 가능하게 하는 메커니즘입니다. 종종 작은 배열과 큰 배열이 있을 때, 큰 배열을 대상으로 작은 배열을 여러 번 연산하고자 할 때가 있습니다. 예를 들어, 행렬의 각 행에 상수 벡터를 더하는 걸 생각해보세요. 이는 다음과 같은 방식으로 처리될 수 있습니다:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jt-LJxZS365d"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# 행렬 x의 각 행에 벡터 v를 더한 뒤,\n",
        "# 그 결과를 행렬 y에 저장하고자 합니다\n",
        "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
        "# x =   \"[[1  2  3]\n",
        "#         [4  5  6]\n",
        "#         [7  8  9]\n",
        "#         [10 11 12]]\"\n",
        "\n",
        "v = np.array([1, 0, 1])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mM8Ns-s27dcc"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-7qf8vW17gfh"
      },
      "source": [
        "v"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NlMN8-eD7itj"
      },
      "source": [
        "x.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mdTItwZH7khS"
      },
      "source": [
        "v.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VxaXYMf17oc3"
      },
      "source": [
        "y = np.empty_like(x)   # x와 동일한 shape를 가지며 비어있는 행렬 생성\n",
        "\n",
        "y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ytOKGmgf7s8A"
      },
      "source": [
        "# 명시적 반복문을 통해 행렬 x의 각 행에 벡터 v를 더하는 방법\n",
        "for i in range(4):\n",
        "    y[i, :] = x[i, :] + v\n",
        "\n",
        "# 이제 y는 다음과 같습니다\n",
        "# [[ 2  2  4]\n",
        "#  [ 5  5  7]\n",
        "#  [ 8  8 10]\n",
        "#  [11 11 13]]\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TS7aVqJH4AZd"
      },
      "source": [
        "위의 방식대로 하면 됩니다; 그러나 `x`가 매우 큰 행렬이라면, 파이썬의 반복문을 이용한 위 코드는 매우 느려질 수 있습니다.\n",
        "\n",
        "벡터 `v`를 행렬 `x`의 각 행에 더하는 것은 `v`를 여러 개 복사해 수직으로 쌓은 행렬 `vv`를 만들고 이 `vv`를 `x`에 더하는것과 동일합니다.\n",
        "\n",
        "이 과정을 아래처럼 구현할 수 있습니다:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ALVbwRLD4EU5"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# 벡터 v를 행렬 x의 각 행에 더한 뒤,\n",
        "# 그 결과를 행렬 y에 저장하고자 합니다\n",
        "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
        "v = np.array([1, 0, 1])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KjJQJFHR8MvE"
      },
      "source": [
        "vv = np.tile(v, (4, 1))   # v의 복사본 4개를 위로 차곡차곡 쌓은 것이 vv\n",
        "\n",
        "vv.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SftbRUUj8Ykc"
      },
      "source": [
        "print(vv)                 # 출력 \"[[1 0 1]\n",
        "                          #       [1 0 1]\n",
        "                          #       [1 0 1]\n",
        "                          #       [1 0 1]]\"\n",
        "y = x + vv  # x와 vv의 요소별 합\n",
        "print(y)    # 출력 \"[[ 2  2  4\n",
        "            #       [ 5  5  7]\n",
        "            #       [ 8  8 10]\n",
        "            #       [11 11 13]]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q5fnf7ub4DNk"
      },
      "source": [
        "Numpy 브로드캐스팅을 이용한다면 이렇게 v의 복사본을 여러 개 만들지 않아도 동일한 연산을 할 수 있습니다. 아래는 브로드캐스팅을 이용한 예시 코드입니다:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bCqCOn4l4NGD"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# 벡터 v를 행렬 x의 각 행에 더한 뒤,\n",
        "# 그 결과를 행렬 y에 저장하고자 합니다\n",
        "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
        "v = np.array([1, 0, 1])\n",
        "y = x + v  # 브로드캐스팅을 이용하여 v를 x의 각 행에 더하기\n",
        "print(y)  # 출력 \"[[ 2  2  4]\n",
        "          #       [ 5  5  7]\n",
        "          #       [ 8  8 10]\n",
        "          #       [11 11 13]]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0YKozO6EBgEQ"
      },
      "source": [
        "(강의 처음에 나온, 수학점수 다차원 배열에 +1 한 코드도 사실은 브로드캐스팅이었습니다!)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xz6ed7rh4TjN"
      },
      "source": [
        "x의 shape가 (4, 3)이고 v의 shape가 (3,)라도 브로드캐스팅으로 인해 y = x + v는 문제없이 수행됩니다.\n",
        "\n",
        "이때 `v`는 `v`의 복사본이 차곡차곡 쌓인 shape (4, 3)처럼 간주되어 `x`와 동일한 shape가 되며 이들 간의 요소별 덧셈연산이 y에 저장됩니다.\n",
        "\n",
        "두 배열의 브로드캐스팅은 아래의 규칙을 따릅니다:\n",
        "\n",
        "1. 두 배열이 동일한 dimension을 가지고 있지 않다면, 낮은 dimension의 1차원 배열이 높은 dimension 배열의 shape로 간주합니다.\n",
        "2. 특정 차원에서 두 배열이 동일한 크기를 갖거나, 두 배열 중 하나의 크기가 1이라면 그 두 배열은 특정 차원에서 compatible하다고 여겨집니다.\n",
        "3. 두 행렬이 모든 차원에서 compatible하다면, 브로드캐스팅이 가능합니다.\n",
        "4. 브로드캐스팅이 이뤄지면, 각 배열 shape의 요소별 최소공배수로 이루어진 shape가 두 배열의 shape로 간주합니다.\n",
        "5. 차원에 상관없이 크기가 1인 배열과 1보다 큰 배열이 있을 때, 크기가 1인 배열은 자신의 차원 수만큼 복사되어 쌓인 것처럼 간주합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ngKciAsj4bM-"
      },
      "source": [
        "브로드캐스팅을 지원하는 함수를 universal functions라고 합니다. \n",
        "\n",
        "https://docs.scipy.org/doc/numpy/reference/ufuncs.html\n",
        "\n",
        "브로드캐스팅을 응용한 예시들입니다:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y3rAVEb34d03"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "v = np.array([1,2,3])  # v의 shape는 (3,)\n",
        "w = np.array([4,5])    # w의 shape는 (2,)\n",
        "x = np.array([[1,2,3], \n",
        "              [4,5,6]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YybmNf-Uynmr"
      },
      "source": [
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Nl3kWPTyuha"
      },
      "source": [
        "# 벡터를 행렬의 각 행에 더하기\n",
        "# x는 shape가 (2, 3)이고 v는 shape가 (3,)이므로 이 둘을 브로드캐스팅하면 shape가 (2, 3)인\n",
        "# 아래와 같은 행렬이 나옵니다:\n",
        "# [[2 4 6]\n",
        "#  [5 7 9]]\n",
        "print(x + v)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fOq_hbEW993m"
      },
      "source": [
        "x.T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-kkH3_069_sa"
      },
      "source": [
        "w"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OY6jCvOF-Cls"
      },
      "source": [
        "x.T + w"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sn8mkBYE-HaZ"
      },
      "source": [
        "(x.T + w).T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R1sGvZNnyyWm"
      },
      "source": [
        "# 벡터를 행렬의 각 행에 더하기\n",
        "# x는 shape가 (2, 3)이고 w는 shape가 (2,)입니다.\n",
        "# x의 전치행렬은 shape가 (3,2)이며 이는 w와 브로드캐스팅이 가능하고 결과로 shape가 (3,2)인 행렬이 생깁니다;\n",
        "# 이 행렬을 전치하면 shape가 (2,3)인 행렬이 나오며\n",
        "# 이는 행렬 x의 각 열에 벡터 w을 더한 결과와 동일합니다.\n",
        "# 아래의 행렬입니다:\n",
        "# [[ 5  6  7]\n",
        "#  [ 9 10 11]]\n",
        "print((x.T + w).T)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8flNn3d-csG"
      },
      "source": [
        "w"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IS1AtfzQ-ege"
      },
      "source": [
        " np.reshape(w, (2, 1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buxpt-e7yx5E"
      },
      "source": [
        "# 다른 방법은 w를 shape가 (2,1)인 열벡터로 변환하는 것입니다;\n",
        "# 그런 다음 이를 바로 x에 브로드캐스팅해 더하면\n",
        "# 동일한 결과가 나옵니다.\n",
        "print(x + np.reshape(w, (2, 1)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dg-XjQ8EyxqD"
      },
      "source": [
        "# 행렬의 스칼라배:\n",
        "# x 의 shape는 (2, 3)입니다. Numpy는 스칼라를 shape가 ()인 배열로 취급합니다;\n",
        "# 그렇기에 스칼라 값은 (2,3) shape로 브로드캐스트 될 수 있고,\n",
        "# 아래와 같은 결과를 만들어 냅니다:\n",
        "# [[ 2  4  6]\n",
        "#  [ 8 10 12]]\n",
        "print(x * 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7nq1PTCS4lyk"
      },
      "source": [
        "브로드캐스팅은 보통 코드를 간결하고 빠르게 해줍니다, 그러니 가능한 많이 사용하세요."
      ]
    }
  ]
}