From a43aacf0833887076f3fc53398fdde0444fdf625 Mon Sep 17 00:00:00 2001 From: yenru0 Date: Mon, 22 Sep 2025 15:55:18 +0900 Subject: [PATCH] move notebook to notes/* --- .gitignore | 4 +- L3.ipynb | 163 -------------------------- modules/__init__.py | 1 + L2.ipynb => notes/L2.ipynb | 0 notes/L3.ipynb | 225 +++++++++++++++++++++++++++++++++++ notes/L4.ipynb | 232 +++++++++++++++++++++++++++++++++++++ 6 files changed, 461 insertions(+), 164 deletions(-) delete mode 100644 L3.ipynb create mode 100644 modules/__init__.py rename L2.ipynb => notes/L2.ipynb (100%) create mode 100644 notes/L3.ipynb create mode 100644 notes/L4.ipynb diff --git a/.gitignore b/.gitignore index 4bb4026..8a5ab6e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,4 @@ .venv -.vscode \ No newline at end of file +.vscode + +__pycache__ \ No newline at end of file diff --git a/L3.ipynb b/L3.ipynb deleted file mode 100644 index a837176..0000000 --- a/L3.ipynb +++ /dev/null @@ -1,163 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "70f73980", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "id": "e8012b5c", - "metadata": {}, - "source": [ - "# Numerical Optimization\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "bea6fa0f", - "metadata": {}, - "source": [ - "## Linear Classifier\n", - "\n", - "$D = \\set{x_i, y_i }^N_{i=1}$ is given. ($x_i \\in \\R^D,\\, y_i\\in \\set{0, 1}$)\n", - "\n", - "like" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "3ad846b8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "np.random.seed(7)\n", - "\n", - "y = np.random.randint(0, 2, size=20)\n", - "\n", - "x = np.random.normal(0, 0.08, size=(2, 20)) + np.vstack([y / 2 + 0.25, y / 2 + 0.25])\n", - "\n", - "plt.xlim(0, 1)\n", - "plt.ylim(0, 1)\n", - "\n", - "plt.scatter(x[0, :][y == 0], x[1, :][y == 0], color=\"red\", label=\"y = 0\")\n", - "plt.scatter(x[0, :][y == 1], x[1, :][y == 1], color=\"blue\", label=\"y = 1\")\n", - "\n", - "plt.legend()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8b9e393c", - "metadata": {}, - "source": [ - "we want to create a **classifier**" - ] - }, - { - "cell_type": "markdown", - "id": "8bb1768a", - "metadata": {}, - "source": [ - "first, set a target function\n", - "\n", - "$$L(w) = \\frac{1}{2}\\sum_{i}^{N}{| f(x_i; w) - y_i|^2}$$\n", - "\n", - "then how to get $w^* = \\text{argmin} L(w) $: $w$ to get lowest $L(w)$" - ] - }, - { - "cell_type": "markdown", - "id": "18da07bf", - "metadata": {}, - "source": [ - "## Learning (Optimization)\n", - "\n", - "$$f(x; w) = w^Tx$$\n", - "\n", - "$$L(w) = \\frac{1}{2}\\sum{|w^Tx_i - y_i|^2} \\\\=\\frac{1}{2} (w^Tx - y)^2\\\\= \\frac{1}{2}{(w^Tx - y)}^T{(w^Tx - y)}$$\n", - "\n", - "$$\\frac{dL}{dw} = x(x^Tw-y)$$\n", - "\n", - "in order to minimize $L(w)$, \n", - "$$\\left.\\frac{dL}{dw}\\right|_{w=w^*} = 0$$\n", - "\n", - "therefore,\n", - "\n", - "$$\\frac{dL}{dw} = $$\n" - ] - }, - { - "cell_type": "markdown", - "id": "bcb16cc8", - "metadata": {}, - "source": [ - "Analytic Method\n", - "\n", - "$$\\frac{dL}{dw} = 0 \\to$$\n", - "\n", - "Numerical Method\n", - "\n", - "* gradient descent\n", - "\n", - "$$w_{t+1} = w_t - \\eta \\left . \\frac{dL}{dw} \\right |_{w=w_t}$$" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "71cb6971", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "6577fc8a", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "2025-02-AI (3.12.11)", - "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.12.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/modules/__init__.py b/modules/__init__.py new file mode 100644 index 0000000..3b3590a --- /dev/null +++ b/modules/__init__.py @@ -0,0 +1 @@ +from .hello import * \ No newline at end of file diff --git a/L2.ipynb b/notes/L2.ipynb similarity index 100% rename from L2.ipynb rename to notes/L2.ipynb diff --git a/notes/L3.ipynb b/notes/L3.ipynb new file mode 100644 index 0000000..4dc481d --- /dev/null +++ b/notes/L3.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "70f73980", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "plt.rcParams[\"font.family\"] = \"D2Coding\"" + ] + }, + { + "cell_type": "markdown", + "id": "e8012b5c", + "metadata": {}, + "source": [ + "# Numerical Optimization\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "bea6fa0f", + "metadata": {}, + "source": [ + "## Linear Classifier\n", + "\n", + "$D = \\set{x_i, y_i }^N_{i=1}$ is given. ($x_i \\in \\R^D,\\, y_i\\in \\set{0, 1}$)\n", + "\n", + "like" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3ad846b8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(7)\n", + "\n", + "y = np.random.randint(0, 2, size=20)\n", + "\n", + "x = np.random.normal(0, 0.08, size=(2, 20)) + np.vstack([y / 2 + 0.25, y / 2 + 0.25])\n", + "\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 1)\n", + "\n", + "plt.scatter(x[0, :][y == 0], x[1, :][y == 0], color=\"red\", label=\"y = 0\")\n", + "plt.scatter(x[0, :][y == 1], x[1, :][y == 1], color=\"blue\", label=\"y = 1\")\n", + "\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8b9e393c", + "metadata": {}, + "source": [ + "we want to create a **classifier**" + ] + }, + { + "cell_type": "markdown", + "id": "8bb1768a", + "metadata": {}, + "source": [ + "first, set a target function\n", + "\n", + "$$L(w) = \\frac{1}{2}\\sum_{i}^{N}{| f(x_i; w) - y_i|^2}$$\n", + "\n", + "then how to get $w^* = \\text{argmin} L(w) $: $w$ to get lowest $L(w)$" + ] + }, + { + "cell_type": "markdown", + "id": "18da07bf", + "metadata": {}, + "source": [ + "## Learning (Optimization)\n", + "\n", + "$$f(x; w) = w^Tx$$\n", + "\n", + "\n", + "$$\\begin{align}\n", + "L(w) &= \n", + "\\end{align}$$\n", + "$$L(w) = \\frac{1}{2}\\sum{|w^Tx_i - y_i|^2} \\\\=\\frac{1}{2} (w^Tx - y)^2\\\\= \\frac{1}{2}{(w^Tx - y)}^T{(w^Tx - y)}$$\n", + "\n", + "$$\\frac{dL}{dw} = x(x^Tw-y)$$\n", + "\n", + "in order to minimize $L(w)$, \n", + "$$\\left.\\frac{dL}{dw}\\right|_{w=w^*} = 0$$\n", + "\n", + "therefore,\n", + "\n", + "$$\\frac{dL}{dw} = $$\n" + ] + }, + { + "cell_type": "markdown", + "id": "bcb16cc8", + "metadata": {}, + "source": [ + "Analytic Method\n", + "\n", + "$$\\frac{dL}{dw} = 0 \\to$$\n", + "\n", + "Numerical Method\n", + "\n", + "* gradient descent\n", + "\n", + "$$w_{t+1} = w_t - \\eta \\left . \\frac{dL}{dw} \\right |_{w=w_t}$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71cb6971", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4162a28f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(7)\n", + "w = np.random.randn(2)\n", + "\n", + "# Learning rate\n", + "eta = 0.1\n", + "\n", + "# Number of iterations\n", + "num_iters = 10_000\n", + "\n", + "\n", + "# Gradient descent loop\n", + "for i in range(num_iters):\n", + " # Compute predictions\n", + " y_pred = np.dot(w, x)\n", + " # Compute gradient\n", + " grad = np.dot(x, (y_pred - y))\n", + " # Update weights\n", + " w -= eta * grad / len(y)\n", + "\n", + "\n", + "# Plot separator\n", + "plt.title(\"separator of x using gradient descent\")\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 1)\n", + "plt.scatter(x[0, :][y == 0], x[1, :][y == 0], color=\"red\", label=\"y = 0\")\n", + "plt.scatter(x[0, :][y == 1], x[1, :][y == 1], color=\"blue\", label=\"y = 1\")\n", + "\n", + "# Separator line: w0*x + w1*y = 0.5\n", + "xx = np.linspace(0, 1, 100)\n", + "yy = (0.5 - w[0] * xx) / w[1]\n", + "plt.plot(xx, yy, \"k--\", label=\"Separator\")\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fbe4845a", + "metadata": {}, + "source": [ + "# Logistic Regression" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "2025-02-AI (3.12.11)", + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notes/L4.ipynb b/notes/L4.ipynb new file mode 100644 index 0000000..26e7ba7 --- /dev/null +++ b/notes/L4.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 37, + "id": "cce80b24", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "plt.rcParams[\"font.family\"] = \"D2Coding\"" + ] + }, + { + "cell_type": "markdown", + "id": "d2df6767", + "metadata": {}, + "source": [ + "# Geometric Interpretation of LR\n", + "\n", + "## Definition\n", + "$$X, W\\in \\R^D$$\n", + "\n", + "$$W^TX = \\lVert W \\rVert \\lVert X \\rVert \\cos \\theta$$\n", + "\n", + "$$\\lVert X-W \\rVert^2 = \\lVert X \\rVert ^2 + \\lVert W \\rVert - 2 W^TX$$\n", + "\n", + "\n", + "$$\\lVert X \\rVert \\cos \\theta = \\frac{W^T X} {\\lVert W \\rVert} $$\n", + "it means length of projected vector." + ] + }, + { + "cell_type": "markdown", + "id": "28627e12", + "metadata": {}, + "source": [ + "$\\begin{cases}\n", + "W^TX_i \\geq b &\\to y_i = 1\\\\\n", + "W_TX_i < b &\\to y_i = 2\n", + "\\end{cases}$" + ] + }, + { + "cell_type": "markdown", + "id": "7d9d80da", + "metadata": {}, + "source": [ + "$\\sum \\frac{1}{2} \\left\\Vert f(x_i;w) - y_i\\right\\Vert$" + ] + }, + { + "cell_type": "markdown", + "id": "d0086883", + "metadata": { + "vscode": { + "languageId": "powershell" + } + }, + "source": [ + "## Likelihood\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "81be7a4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(7)\n", + "\n", + "#y = np.random.randint(0, 2, size=20)\n", + "\n", + "#x = np.random.normal(0, 0.08, size=(2, 20)) + np.vstack([y / 2 + 0.25, y / 2 + 0.25])\n", + "\n", + "\n", + "x = np.random.normal(0.5, 0.2, size=(40, 2), )\n", + "plt.xlim(0, 1)\n", + "plt.ylim(0, 1)\n", + "\n", + "plt.scatter(x[:, 0], x[:, 1], color='blue')\n", + "#plt.scatter(x[0, :][y == 0], x[1, :][y == 0], color=\"red\", label=\"y = 0\")\n", + "#plt.scatter(x[0, :][y == 1], x[1, :][y == 1], color=\"blue\", label=\"y = 1\")\n", + "\n", + "#plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "df8f9d0b", + "metadata": {}, + "source": [ + "Maximize the probability" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "417911ef", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "620ef30c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLE estimated mu: [0.50995502 0.46521124]\n", + "MLE estimated sigma: [0.19530993 0.22297348]\n" + ] + } + ], + "source": [ + "# X가 2차원 데이터이므로 각 차원별로 평균(mu)과 표준편차(sigma)를 추정합니다.\n", + "# MLE: mu = sample mean, sigma = sample std (biased=False)\n", + "mu_mle = np.mean(x, axis=0)\n", + "sigma_mle = np.std(x, axis=0, ddof=0) # ddof=0 for MLE\n", + "\n", + "print(\"MLE estimated mu:\", mu_mle)\n", + "print(\"MLE estimated sigma:\", sigma_mle)" + ] + }, + { + "cell_type": "markdown", + "id": "c51e029e", + "metadata": {}, + "source": [ + "to assign high probability to the observed data" + ] + }, + { + "cell_type": "markdown", + "id": "36b7c733", + "metadata": {}, + "source": [ + "## Logistic Regression RV\n", + "\n", + "$y_i \\in \\set{0, 1}$\n", + "$x_i \\in \\R^D$\n", + "\n", + "logistic regression function\n", + "$$f(X;W) = \\frac{1}{1+\\exp(-W^TX)}$$\n", + "\n", + "$$\\text{max}\\; L(w) = \\prod_{i=1}^{N}f(x_i)^{y_i} (1-f(x_i))^{1-y_i}$$\n", + "where\n", + "* $f(x_i)$: prob of choosing $y_i = 1$\n", + "* $1-f(x_i)$: prob of choosing $y_i = 0$\n", + "\n", + "and then update like\n", + "$$w_{t+1} = w_t + \\eta \\left . \\frac{dL}{dw}\\right\\vert_{w=w_t}$$\n", + "\n", + "how to get:\n", + "\n", + "$$w^* = \\argmax L(w) = \\argmax \\ln L(w)$$\n", + "\n", + "because function $\\ln$ is monotonically increasing function\n", + "\n", + "so $\\ln L(w) = \\sum_{i=1}^{N}{(y_i\\ln f(x_i) + (1-y_i)\\ln(1-f(x_i)) )}$\n", + "\n", + "미분하면 된다" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b19eb64", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cba17457", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b189852", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "2025-02-AI (3.12.11)", + "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.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}