Matrix.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Polars(いわゆるPandas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Timing: true\n",
       "sccache: true\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 2411ms</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":timing\n",
    ":sccache 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 432394ms</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":dep polars = { version = \"0.14.7\", features = [\"ndarray\", \"random\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 2193ms</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#[macro_use]\n",
    "extern crate polars;\n",
    "use polars::prelude::*;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 演算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3,)\n",
       "Series: '' [i32]\n",
       "[\n",
       "\t1\n",
       "\t2\n",
       "\t3\n",
       "]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 9454ms</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let s: Series = [1, 2, 3].iter().collect();\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3,)\n",
       "Series: 'A' [i32]\n",
       "[\n",
       "\t1\n",
       "\t2\n",
       "\t3\n",
       "]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 4047ms</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Series::new(\"A\", &[1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t2\n",
      "\t3\n",
      "\t4\n",
      "]\n",
      "sub:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t0\n",
      "\t1\n",
      "\t2\n",
      "]\n",
      "mul:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t2\n",
      "\t4\n",
      "\t6\n",
      "]\n",
      "div:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t0\n",
      "\t1\n",
      "\t1\n",
      "]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 4637ms</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println!(\"add:\\n{:?}\", &s + 1);\n",
    "println!(\"sub:\\n{:?}\", &s - 1);\n",
    "println!(\"mul:\\n{:?}\", &s * 2);\n",
    "println!(\"div:\\n{:?}\", &s / 2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t2\n",
      "\t3\n",
      "\t4\n",
      "]\n",
      "sub:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t0\n",
      "\t1\n",
      "\t2\n",
      "]\n",
      "mul:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t2\n",
      "\t4\n",
      "\t6\n",
      "]\n",
      "div:\n",
      "shape: (3,)\n",
      "Series: '' [i32]\n",
      "[\n",
      "\t0\n",
      "\t1\n",
      "\t1\n",
      "]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 3422ms</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println!(\"add:\\n{:?}\", &s + 1);\n",
    "println!(\"sub:\\n{:?}\", &s - 1);\n",
    "println!(\"mul:\\n{:?}\", &s * 2);\n",
    "println!(\"div:\\n{:?}\", &s / 2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列選択"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 5363ms</span>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut df = df!(\"A\" => &[\"a\", \"b\", \"a\"],\n",
    "             \"B\" => &[1, 3, 5],\n",
    "             \"C\" => &[10, 11, 12],\n",
    "             \"D\" => &[2, 4, 6],\n",
    "            \"E\" => &[1, 3, 5]\n",
    "    )?;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3, 1)\n",
       "+-----+\n",
       "| A   |\n",
       "| --- |\n",
       "| str |\n",
       "+=====+\n",
       "| \"a\" |\n",
       "+-----+\n",
       "| \"b\" |\n",
       "+-----+\n",
       "| \"a\" |\n",
       "+-----+\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 3352ms</span>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let selectA = df.select(\"A\")?;\n",
    "selectA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3, 2)\n",
       "+-----+-----+\n",
       "| A   | B   |\n",
       "| --- | --- |\n",
       "| str | i32 |\n",
       "+=====+=====+\n",
       "| \"a\" | 1   |\n",
       "+-----+-----+\n",
       "| \"b\" | 3   |\n",
       "+-----+-----+\n",
       "| \"a\" | 5   |\n",
       "+-----+-----+\n"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 2950ms</span>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let selectB = df.select((\"A\", \"B\"))?;\n",
    "selectB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3, 3)\n",
       "+-----+-----+-----+\n",
       "| A   | B   | C   |\n",
       "| --- | --- | --- |\n",
       "| str | i32 | i32 |\n",
       "+=====+=====+=====+\n",
       "| \"a\" | 1   | 10  |\n",
       "+-----+-----+-----+\n",
       "| \"b\" | 3   | 11  |\n",
       "+-----+-----+-----+\n",
       "| \"a\" | 5   | 12  |\n",
       "+-----+-----+-----+\n"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 3211ms</span>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let selectC = df.select(vec![\"A\", \"B\", \"C\"])?;\n",
    "selectC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 重複行の抽出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (0, 5)\n",
       "++\n",
       "||\n",
       "||\n",
       "||\n",
       "++\n",
       "++\n"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 3558ms</span>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let dup = df.filter(&df.is_duplicated()?)?;\n",
    "dup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (3, 5)\n",
       "+-----+-----+-----+-----+-----+\n",
       "| A   | B   | C   | D   | E   |\n",
       "| --- | --- | --- | --- | --- |\n",
       "| str | i32 | i32 | i32 | i32 |\n",
       "+=====+=====+=====+=====+=====+\n",
       "| \"a\" | 1   | 10  | 2   | 1   |\n",
       "+-----+-----+-----+-----+-----+\n",
       "| \"b\" | 3   | 11  | 4   | 3   |\n",
       "+-----+-----+-----+-----+-----+\n",
       "| \"a\" | 5   | 12  | 6   | 5   |\n",
       "+-----+-----+-----+-----+-----+\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 4204ms</span>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.drop_duplicates(true, None)? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## READ CSV\n",
    "\n",
    "pandasといえばこれ\n",
    "```python\n",
    "df = pd.read_csv(path)\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 8910ms</span>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let csv = CsvReader::from_path(\"sample.csv\")?\n",
    "        .infer_schema(None)\n",
    "        .with_delimiter(b',')\n",
    "        .has_header(true)\n",
    "        .finish()?;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "shape: (1, 3)\n",
       "+-----+-----+------+\n",
       "| 1   | 2   | 3    |\n",
       "| --- | --- | ---  |\n",
       "| i64 | i64 | i64  |\n",
       "+=====+=====+======+\n",
       "| 4   | 5   | null |\n",
       "+-----+-----+------+\n"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 3355ms</span>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"color: rgba(0,0,0,0.4);\">Took 4280ms</span>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let df1: DataFrame = df!(\"Fruit\" => &[\"Apple\", \"Banana\", \"Pear\"])?;\n",
    "let df2: DataFrame = df!(\"Name\" => &[\"Apple\", \"Banana\", \"Pear\"])?;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "this function takes 4 arguments but 5 arguments were supplied",
     "output_type": "error",
     "traceback": [
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m         ^^^^\u001b[0m \u001b[94m\u001b[0m",
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m               ^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m                        ^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m                                ^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m                                                            ^^^^\u001b[0m \u001b[94msupplied 5 arguments\u001b[0m",
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m    ^^^^\u001b[0m \u001b[94mexpected 4 arguments\u001b[0m",
      "this function takes 4 arguments but 5 arguments were supplied"
     ]
    },
    {
     "ename": "Error",
     "evalue": "ambiguous associated type",
     "output_type": "error",
     "traceback": [
      "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)",
      "\u001b[91m                                ^^^^^^^^^^^^^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "ambiguous associated type",
      "\u001b[1mhelp\u001b[0m: use fully-qualified syntax\n\n<polars::prelude::DataFrame as Trait>::joinType"
     ]
    }
   ],
   "source": [
    "df1.join(&df2, \"Fruit\", \"Name\", DataFrame::joinType::Inner, None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 公式による詳細コードはこちら\n",
    "\n",
    "https://github.com/LaurentMazare/tch-rs/tree/main/examples/mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "file not found for module `mnist_conv`",
     "output_type": "error",
     "traceback": [
      "mod mnist_conv;",
      "\u001b[91m^^^^^^^^^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "file not found for module `mnist_conv`",
      "\u001b[1mhelp\u001b[0m: to create the module `mnist_conv`, create file \"src/mnist_conv.rs\" or \"src/mnist_conv/mod.rs\""
     ]
    },
    {
     "ename": "Error",
     "evalue": "file not found for module `mnist_linear`",
     "output_type": "error",
     "traceback": [
      "mod mnist_linear;",
      "\u001b[91m^^^^^^^^^^^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "file not found for module `mnist_linear`",
      "\u001b[1mhelp\u001b[0m: to create the module `mnist_linear`, create file \"src/mnist_linear.rs\" or \"src/mnist_linear/mod.rs\""
     ]
    },
    {
     "ename": "Error",
     "evalue": "file not found for module `mnist_nn`",
     "output_type": "error",
     "traceback": [
      "mod mnist_nn;",
      "\u001b[91m^^^^^^^^^^^^^\u001b[0m \u001b[94m\u001b[0m",
      "file not found for module `mnist_nn`",
      "\u001b[1mhelp\u001b[0m: to create the module `mnist_nn`, create file \"src/mnist_nn.rs\" or \"src/mnist_nn/mod.rs\""
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `anyhow`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `anyhow`",
      "unresolved import `anyhow`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find function `run` in module `mnist_nn`",
     "output_type": "error",
     "traceback": [
      "        None => mnist_nn::run(),",
      "\u001b[91m                          ^^^\u001b[0m \u001b[94mnot found in `mnist_nn`\u001b[0m",
      "cannot find function `run` in module `mnist_nn`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find function `run` in module `mnist_linear`",
     "output_type": "error",
     "traceback": [
      "        Some(\"linear\") => mnist_linear::run(),",
      "\u001b[91m                                        ^^^\u001b[0m \u001b[94mnot found in `mnist_linear`\u001b[0m",
      "cannot find function `run` in module `mnist_linear`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find function `run` in module `mnist_conv`",
     "output_type": "error",
     "traceback": [
      "        Some(\"conv\") => mnist_conv::run(),",
      "\u001b[91m                                    ^^^\u001b[0m \u001b[94mnot found in `mnist_conv`\u001b[0m",
      "cannot find function `run` in module `mnist_conv`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find function `run` in module `mnist_nn`",
     "output_type": "error",
     "traceback": [
      "        Some(_) => mnist_nn::run(),",
      "\u001b[91m                             ^^^\u001b[0m \u001b[94mnot found in `mnist_nn`\u001b[0m",
      "cannot find function `run` in module `mnist_nn`"
     ]
    }
   ],
   "source": [
    "use anyhow::Result;\n",
    "\n",
    "mod mnist_conv;\n",
    "mod mnist_linear;\n",
    "mod mnist_nn;\n",
    "\n",
    "fn main() -> Result<()> {\n",
    "    let args: Vec<String> = std::env::args().collect();\n",
    "    let model = if args.len() < 2 {\n",
    "        None\n",
    "    } else {\n",
    "        Some(args[1].as_str())\n",
    "    };\n",
    "    match model {\n",
    "        None => mnist_nn::run(),\n",
    "        Some(\"linear\") => mnist_linear::run(),\n",
    "        Some(\"conv\") => mnist_conv::run(),\n",
    "        Some(_) => mnist_nn::run(),\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `anyhow`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `anyhow`",
      "unresolved import `anyhow`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "    let m = tch::vision::mnist::load_dir(\"data\")?;",
      "\u001b[91m            ^^^\u001b[0m \u001b[94muse of undeclared crate or module `tch`\u001b[0m",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    }
   ],
   "source": [
    "// CNN model. This should rearch 99.1% accuracy.\n",
    "\n",
    "use anyhow::Result;\n",
    "use tch::{nn, nn::ModuleT, nn::OptimizerConfig, Device, Tensor};\n",
    "\n",
    "#[derive(Debug)]\n",
    "struct Net {\n",
    "    conv1: nn::Conv2D,\n",
    "    conv2: nn::Conv2D,\n",
    "    fc1: nn::Linear,\n",
    "    fc2: nn::Linear,\n",
    "}\n",
    "\n",
    "impl Net {\n",
    "    fn new(vs: &nn::Path) -> Net {\n",
    "        let conv1 = nn::conv2d(vs, 1, 32, 5, Default::default());\n",
    "        let conv2 = nn::conv2d(vs, 32, 64, 5, Default::default());\n",
    "        let fc1 = nn::linear(vs, 1024, 1024, Default::default());\n",
    "        let fc2 = nn::linear(vs, 1024, 10, Default::default());\n",
    "        Net {\n",
    "            conv1,\n",
    "            conv2,\n",
    "            fc1,\n",
    "            fc2,\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "impl nn::ModuleT for Net {\n",
    "    fn forward_t(&self, xs: &Tensor, train: bool) -> Tensor {\n",
    "        xs.view([-1, 1, 28, 28])\n",
    "            .apply(&self.conv1)\n",
    "            .max_pool2d_default(2)\n",
    "            .apply(&self.conv2)\n",
    "            .max_pool2d_default(2)\n",
    "            .view([-1, 1024])\n",
    "            .apply(&self.fc1)\n",
    "            .relu()\n",
    "            .dropout_(0.5, train)\n",
    "            .apply(&self.fc2)\n",
    "    }\n",
    "}\n",
    "\n",
    "pub fn run() -> Result<()> {\n",
    "    let m = tch::vision::mnist::load_dir(\"data\")?;\n",
    "    let vs = nn::VarStore::new(Device::cuda_if_available());\n",
    "    let net = Net::new(&vs.root());\n",
    "    let mut opt = nn::Adam::default().build(&vs, 1e-4)?;\n",
    "    for epoch in 1..100 {\n",
    "        for (bimages, blabels) in m.train_iter(256).shuffle().to_device(vs.device()) {\n",
    "            let loss = net\n",
    "                .forward_t(&bimages, true)\n",
    "                .cross_entropy_for_logits(&blabels);\n",
    "            opt.backward_step(&loss);\n",
    "        }\n",
    "        let test_accuracy =\n",
    "            net.batch_accuracy_for_logits(&m.test_images, &m.test_labels, vs.device(), 1024);\n",
    "        println!(\"epoch: {:4} test acc: {:5.2}%\", epoch, 100. * test_accuracy,);\n",
    "    }\n",
    "    Ok(())\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `anyhow`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `anyhow`",
      "unresolved import `anyhow`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    }
   ],
   "source": [
    "// This should rearch 91.5% accuracy.\n",
    "\n",
    "use anyhow::Result;\n",
    "use tch::{kind, no_grad, vision, Kind, Tensor};\n",
    "\n",
    "const IMAGE_DIM: i64 = 784;\n",
    "const LABELS: i64 = 10;\n",
    "\n",
    "pub fn run() -> Result<()> {\n",
    "    let m = vision::mnist::load_dir(\"data\")?;\n",
    "    println!(\"train-images: {:?}\", m.train_images.size());\n",
    "    println!(\"train-labels: {:?}\", m.train_labels.size());\n",
    "    println!(\"test-images: {:?}\", m.test_images.size());\n",
    "    println!(\"test-labels: {:?}\", m.test_labels.size());\n",
    "    let mut ws = Tensor::zeros(&[IMAGE_DIM, LABELS], kind::FLOAT_CPU).set_requires_grad(true);\n",
    "    let mut bs = Tensor::zeros(&[LABELS], kind::FLOAT_CPU).set_requires_grad(true);\n",
    "    for epoch in 1..200 {\n",
    "        let logits = m.train_images.mm(&ws) + &bs;\n",
    "        let loss = logits\n",
    "            .log_softmax(-1, Kind::Float)\n",
    "            .nll_loss(&m.train_labels);\n",
    "        ws.zero_grad();\n",
    "        bs.zero_grad();\n",
    "        loss.backward();\n",
    "        no_grad(|| {\n",
    "            ws += ws.grad() * (-1);\n",
    "            bs += bs.grad() * (-1);\n",
    "        });\n",
    "        let test_logits = m.test_images.mm(&ws) + &bs;\n",
    "        let test_accuracy = test_logits\n",
    "            .argmax(Some(-1), false)\n",
    "            .eq_tensor(&m.test_labels)\n",
    "            .to_kind(Kind::Float)\n",
    "            .mean(Kind::Float)\n",
    "            .double_value(&[]);\n",
    "        println!(\n",
    "            \"epoch: {:4} train loss: {:8.5} test acc: {:5.2}%\",\n",
    "            epoch,\n",
    "            loss.double_value(&[]),\n",
    "            100. * test_accuracy\n",
    "        );\n",
    "    }\n",
    "    Ok(())\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `tch`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `tch`",
      "unresolved import `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "unresolved import `anyhow`",
     "output_type": "error",
     "traceback": [
      "use of undeclared crate or module `anyhow`",
      "unresolved import `anyhow`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "failed to resolve: use of undeclared crate or module `tch`",
     "output_type": "error",
     "traceback": [
      "    let m = tch::vision::mnist::load_dir(\"data\")?;",
      "\u001b[91m            ^^^\u001b[0m \u001b[94muse of undeclared crate or module `tch`\u001b[0m",
      "failed to resolve: use of undeclared crate or module `tch`"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot find trait `Module` in this scope",
     "output_type": "error",
     "traceback": [
      "fn net(vs: &nn::Path) -> impl Module {",
      "\u001b[91m                              ^^^^^^\u001b[0m \u001b[94mnot found in this scope\u001b[0m",
      "cannot find trait `Module` in this scope"
     ]
    }
   ],
   "source": [
    "// This should rearch 97% accuracy.\n",
    "\n",
    "use anyhow::Result;\n",
    "use tch::{nn, nn::Module, nn::OptimizerConfig, Device};\n",
    "\n",
    "const IMAGE_DIM: i64 = 784;\n",
    "const HIDDEN_NODES: i64 = 128;\n",
    "const LABELS: i64 = 10;\n",
    "\n",
    "fn net(vs: &nn::Path) -> impl Module {\n",
    "    nn::seq()\n",
    "        .add(nn::linear(\n",
    "            vs / \"layer1\",\n",
    "            IMAGE_DIM,\n",
    "            HIDDEN_NODES,\n",
    "            Default::default(),\n",
    "        ))\n",
    "        .add_fn(|xs| xs.relu())\n",
    "        .add(nn::linear(vs, HIDDEN_NODES, LABELS, Default::default()))\n",
    "}\n",
    "\n",
    "pub fn run() -> Result<()> {\n",
    "    let m = tch::vision::mnist::load_dir(\"data\")?;\n",
    "    let vs = nn::VarStore::new(Device::Cpu);\n",
    "    let net = net(&vs.root());\n",
    "    let mut opt = nn::Adam::default().build(&vs, 1e-3)?;\n",
    "    for epoch in 1..200 {\n",
    "        let loss = net\n",
    "            .forward(&m.train_images)\n",
    "            .cross_entropy_for_logits(&m.train_labels);\n",
    "        opt.backward_step(&loss);\n",
    "        let test_accuracy = net\n",
    "            .forward(&m.test_images)\n",
    "            .accuracy_for_logits(&m.test_labels);\n",
    "        println!(\n",
    "            \"epoch: {:4} train loss: {:8.5} test acc: {:5.2}%\",\n",
    "            epoch,\n",
    "            f64::from(&loss),\n",
    "            100. * f64::from(&test_accuracy),\n",
    "        );\n",
    "    }\n",
    "    Ok(())\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}