{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Early stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Installing packages:\n",
      "\t.package(path: \"/home/ubuntu/fastai_docs/dev_swift/FastaiNotebook_05_anneal\")\n",
      "\t\tFastaiNotebook_05_anneal\n",
      "With SwiftPM flags: []\n",
      "Working in: /tmp/tmpm75u2_zd\n",
      "Fetching https://github.com/mxcl/Path.swift\n",
      "Fetching https://github.com/JustHTTP/Just\n",
      "Completed resolution in 2.69s\n",
      "Cloning https://github.com/JustHTTP/Just\n",
      "Resolving https://github.com/JustHTTP/Just at 0.7.1\n",
      "Cloning https://github.com/mxcl/Path.swift\n",
      "Resolving https://github.com/mxcl/Path.swift at 0.16.2\n",
      "Compile Swift Module 'Just' (1 sources)\n",
      "Compile Swift Module 'Path' (9 sources)\n",
      "Compile Swift Module 'FastaiNotebook_05_anneal' (8 sources)\n",
      "Compile Swift Module 'jupyterInstalledPackages' (1 sources)\n",
      "Linking ./.build/x86_64-unknown-linux/debug/libjupyterInstalledPackages.so\n",
      "Initializing Swift...\n",
      "Loading library...\n",
      "Installation complete!\n"
     ]
    }
   ],
   "source": [
    "%install '.package(path: \"$cwd/FastaiNotebook_05_anneal\")' FastaiNotebook_05_anneal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('inline', 'module://ipykernel.pylab.backend_inline')\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import FastaiNotebook_05_anneal\n",
    "%include \"EnableIPythonDisplay.swift\"\n",
    "IPythonDisplay.shell.enable_matplotlib(\"inline\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "import Path\n",
    "import TensorFlow\n",
    "import Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let data = mnistDataBunch(flat: true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let (n,m) = (60000,784)\n",
    "let c = 10\n",
    "let nHid = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var opt = SGD<BasicModel, Float>(learningRate: 1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func modelInit() -> BasicModel {return BasicModel(nIn: m, nHid: nHid, nOut: c)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let learner = Learner(data: data, lossFunction: softmaxCrossEntropy, optimizer: opt, initializingWith: modelInit)\n",
    "let recorder = learner.makeRecorder()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the previous callbacks load."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.delegates = [learner.makeTrainEvalDelegate(), learner.makeShowProgress(),\n",
    "                     learner.makeNormalize(mean: mnistStats.mean, std: mnistStats.std),\n",
    "                     learner.makeAvgMetric(metrics: [accuracy]), recorder]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: [0.49177492, 0.8759]                                                   \n",
      "Epoch 1: [0.37792677, 0.8985]                                                   \n",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "learner.fit(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make an extension to quickly load them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "//TODO: when recorder can be accessed as a property, remove it from the return\n",
    "extension Learner where Opt.Scalar: PythonConvertible {\n",
    "    public func makeDefaultDelegates(metrics: [(Tensor<Float>, Tensor<Int32>) -> Tensor<Float>] = []) -> Recorder {\n",
    "        let recorder = makeRecorder()\n",
    "        delegates = [makeTrainEvalDelegate(), makeShowProgress(), recorder]\n",
    "        if !metrics.isEmpty { delegates.append(makeAvgMetric(metrics: metrics)) }\n",
    "        return recorder\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extension Learner {\n",
    "    public class TestControlFlow: Delegate {\n",
    "        public override var order: Int { return 3 }\n",
    "        var waitForSkipBatch, waitForSkipEpoch, waitForEndTrain: Int\n",
    "        \n",
    "        public init(nIter:Int, nBatch: Int, nEpoch: Int){ \n",
    "            (waitForSkipBatch, waitForSkipEpoch, waitForEndTrain) = (nIter, nBatch, nEpoch)\n",
    "        }\n",
    "        \n",
    "        public override func learnerDidProduceNewGradient(learner: Learner) throws {\n",
    "            if learner.currentIter >= waitForSkipBatch {throw LearnerAction.skipBatch}\n",
    "        }\n",
    "        \n",
    "        public override func batchDidFinish(learner: Learner) throws {\n",
    "            if learner.currentIter >= waitForSkipBatch {\n",
    "                print(\"batchDidFinish properly executed after skip batch at iter \\(learner.currentIter)\")\n",
    "            }\n",
    "            if learner.currentIter >= waitForSkipEpoch {throw LearnerAction.skipEpoch}\n",
    "            }\n",
    "        \n",
    "        public override func epochDidFinish(learner: Learner) throws {\n",
    "            print(\"epochDidFinish properly executed after skip epoch (number \\(learner.currentEpoch))\")\n",
    "            if learner.currentEpoch >= waitForEndTrain {throw LearnerAction.stop}\n",
    "        }\n",
    "        \n",
    "        public override func trainingDidFinish(learner: Learner){\n",
    "            print(\"trainingDidFinish properly executed after stop\")\n",
    "        }     \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let learner = Learner(data: data, lossFunction: softmaxCrossEntropy, optimizer: opt, initializingWith: modelInit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.delegates = [type(of: learner).TestControlFlow(nIter:5, nBatch: 7, nEpoch: 2),\n",
    "                     learner.makeTrainEvalDelegate()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batchDidFinish properly executed after skip batch at iter 5\n",
      "batchDidFinish properly executed after skip batch at iter 6\n",
      "batchDidFinish properly executed after skip batch at iter 7\n",
      "epochDidFinish properly executed after skip epoch (number 0)\n",
      "batchDidFinish properly executed after skip batch at iter 5\n",
      "batchDidFinish properly executed after skip batch at iter 6\n",
      "batchDidFinish properly executed after skip batch at iter 7\n",
      "epochDidFinish properly executed after skip epoch (number 1)\n",
      "batchDidFinish properly executed after skip batch at iter 5\n",
      "batchDidFinish properly executed after skip batch at iter 6\n",
      "batchDidFinish properly executed after skip batch at iter 7\n",
      "epochDidFinish properly executed after skip epoch (number 2)\n",
      "trainingDidFinish properly executed after stop\n"
     ]
    }
   ],
   "source": [
    "learner.fit(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if the orders were taken into account:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "▿ 2 elements\n",
       "  - .0 : 0\n",
       "  - .1 : 3\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(learner.delegates[0].order,learner.delegates[1].order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LR Finder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "extension Learner where Opt.Scalar: BinaryFloatingPoint {\n",
    "    public class LRFinder: Delegate {\n",
    "        public typealias ScheduleFunc = (Float) -> Float\n",
    "\n",
    "        // A learning rate schedule from step to float.\n",
    "        private var scheduler: ScheduleFunc\n",
    "        private var numIter: Int\n",
    "        private var minLoss: Float? = nil\n",
    "        \n",
    "        public init(start: Float = 1e-5, end: Float = 10, numIter: Int = 100) {\n",
    "            scheduler = makeAnnealer(start: start, end: end, schedule: expSchedule)\n",
    "            self.numIter = numIter\n",
    "        }\n",
    "        \n",
    "        override public func batchWillStart(learner: Learner) {\n",
    "            learner.optimizer.learningRate = Opt.Scalar(scheduler(Float(learner.currentIter)/Float(numIter)))\n",
    "        }\n",
    "        \n",
    "        override public func batchDidFinish(learner: Learner) throws {\n",
    "            if minLoss == nil {minLoss = learner.currentLoss.scalar}\n",
    "            else { \n",
    "                if learner.currentLoss.scalarized() < minLoss! { minLoss = learner.currentLoss.scalarized()}\n",
    "                if learner.currentLoss.scalarized() > 4 * minLoss! { throw LearnerAction.stop }\n",
    "                if learner.currentIter >= numIter { throw LearnerAction.stop }\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        override public func validationWillStart(learner: Learner<Label, Opt>) throws {\n",
    "            //Skip validation during the LR range test\n",
    "            throw LearnerAction.skipEpoch\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    public func makeLRFinder(start: Float = 1e-5, end: Float = 10, numIter: Int = 100) -> LRFinder {\n",
    "        return LRFinder(start: start, end: end, numIter: numIter)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let learner = Learner(data: data, lossFunction: softmaxCrossEntropy, optimizer: opt, initializingWith: modelInit)\n",
    "let recorder = learner.makeDefaultDelegates()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learner.delegates.append(learner.makeNormalize(mean: mnistStats.mean, std: mnistStats.std))\n",
    "learner.delegates.append(learner.makeLRFinder())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                             \r"
     ]
    }
   ],
   "source": [
    "learner.fit(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recorder.plotLRFinder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "//TODO: when Recorder is a property of Learner don't return it.\n",
    "extension Learner where Opt.Scalar: PythonConvertible & BinaryFloatingPoint {\n",
    "    public func lrFind(start: Float = 1e-5, end: Float = 10, numIter: Int = 100) -> Recorder {\n",
    "        let epochCount = data.train.count(where: {_ in true}) / numIter + 1\n",
    "        let recorder = makeDefaultDelegates()\n",
    "        delegates.append(makeLRFinder(start: start, end: end, numIter: numIter))\n",
    "        try! self.fit(epochCount)\n",
    "        return recorder\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                             \r"
     ]
    }
   ],
   "source": [
    "let recorder = learner.lrFind()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recorder.plotLRFinder()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "notebookToScript(fname: (Path.cwd / \"05b_early_stopping.ipynb\").string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Swift",
   "language": "swift",
   "name": "swift"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}