LinearRegression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot\n",
    "using Statistics\n",
    "using Optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0:0.2:10.0"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = 1:0.2:10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46-element Array{Float64,1}:\n",
       "  2.784902797301479\n",
       "  5.98258081625924\n",
       "  4.676530921244562\n",
       "  6.2968069156609205\n",
       "  6.59798211763175\n",
       "  9.058737721541277\n",
       "  7.804847347197226\n",
       "  8.174297672717982\n",
       "  8.497146272546644\n",
       "  9.09149749310574\n",
       " 10.803982394143897\n",
       " 12.084691345656173\n",
       " 11.37592680242307\n",
       "  ⋮\n",
       " 25.137471572704413\n",
       " 26.26839207964284\n",
       " 26.961117933883422\n",
       " 26.01321523060851\n",
       " 26.248310903731404\n",
       " 27.11352090208551\n",
       " 27.45844054229926\n",
       " 28.272370861935855\n",
       " 27.597097197378957\n",
       " 29.25627555010351\n",
       " 33.03338580649507\n",
       " 32.41802148340797"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = map(ti -> 3 * ti + 1 + 1 * randn(), t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.collections.PathCollection object at 0x7ff98e2433d0>"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scatter(t, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45-element Array{Float64,1}:\n",
       " 15.98839009478881\n",
       " -6.530249475073393\n",
       "  8.101379972081785\n",
       "  1.5058760098541462\n",
       " 12.303778019547641\n",
       " -6.26945187172025\n",
       "  1.8472516276037811\n",
       "  1.614242999143308\n",
       "  2.9717561027954837\n",
       "  8.562424505190782\n",
       "  6.403544757561374\n",
       " -3.5438227161655216\n",
       " -1.3085847586134924\n",
       "  ⋮\n",
       "  2.369335799100918\n",
       "  5.654602534692129\n",
       "  3.4636292712029206\n",
       " -4.73951351637454\n",
       "  1.1754783656144816\n",
       "  4.326049991770512\n",
       "  1.724598201068754\n",
       "  4.069651598182983\n",
       " -3.3763683227844683\n",
       "  8.295891763622793\n",
       " 18.885551281957696\n",
       " -3.07682161543551"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [ (y[i]-y[i-1])/(t[i]-t[i-1]) for i in 2:length(t)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.292568742900721"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.589873324661466"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "std(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3.02 +/- 0.75"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22m \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22mm \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22min \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22mout \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22merr \u001b[0m\u001b[1ms\u001b[22me\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22miff \u001b[0m\u001b[1ms\u001b[22me\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1md\u001b[22miff! hi\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m2\u001b[0m\u001b[1mD\u001b[22m \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22mri\u001b[0m\u001b[1md\u001b[22me \u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22mri\u001b[0m\u001b[1md\u001b[22mes\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "std(itr; corrected::Bool=true, mean=nothing[, dims])\n",
       "\\end{verbatim}\n",
       "Compute the sample standard deviation of collection \\texttt{itr}.\n",
       "\n",
       "The algorithm returns an estimator of the generative distribution's standard deviation under the assumption that each entry of \\texttt{itr} is an IID drawn from that generative distribution. For arrays, this computation is equivalent to calculating \\texttt{sqrt(sum((itr .- mean(itr)).\\^{}2) / (length(itr) - 1))}. If \\texttt{corrected} is \\texttt{true}, then the sum is scaled with \\texttt{n-1}, whereas the sum is scaled with \\texttt{n} if \\texttt{corrected} is \\texttt{false} with \\texttt{n} the number of elements in \\texttt{itr}.\n",
       "\n",
       "A pre-computed \\texttt{mean} may be provided.\n",
       "\n",
       "If \\texttt{itr} is an \\texttt{AbstractArray}, \\texttt{dims} can be provided to compute the standard deviation over dimensions, and \\texttt{means} may contain means for each dimension of \\texttt{itr}.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{note}\n",
       "\n",
       "Note\n",
       "\n",
       "If array contains \\texttt{NaN} or \\href{@ref}{\\texttt{missing}} values, the result is also \\texttt{NaN} or \\texttt{missing} (\\texttt{missing} takes precedence if array contains both). Use the \\href{@ref}{\\texttt{skipmissing}} function to omit \\texttt{missing} entries and compute the standard deviation of non-missing values.\n",
       "\n",
       "\\end{quote}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "std(x::AbstractArray, w::AbstractWeights, [dim]; mean=nothing, corrected=false)\n",
       "\\end{verbatim}\n",
       "Compute the standard deviation of a real-valued array \\texttt{x}, optionally over a dimension \\texttt{dim}. Observations in \\texttt{x} are weighted using weight vector \\texttt{w}. The uncorrected (when \\texttt{corrected=false}) sample standard deviation is defined as:\n",
       "\n",
       "$$\\sqrt{\\frac{1}{\\sum{w}} \\sum_{i=1}^n {w_i\\left({x_i - μ}\\right)^2 }}$$\n",
       "where $n$ is the length of the input and $μ$ is the mean. The unbiased estimate (when \\texttt{corrected=true}) of the population standard deviation is computed by replacing $\\frac{1}{\\sum{w}}$ with a factor dependent on the type of weights used:\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item \\texttt{AnalyticWeights}: $\\frac{1}{\\sum w - \\sum {w^2} / \\sum w}$\n",
       "\n",
       "\n",
       "\\item \\texttt{FrequencyWeights}: $\\frac{1}{\\sum{w} - 1}$\n",
       "\n",
       "\n",
       "\\item \\texttt{ProbabilityWeights}: $\\frac{n}{(n - 1) \\sum w}$ where $n$ equals \\texttt{count(!iszero, w)}\n",
       "\n",
       "\n",
       "\\item \\texttt{Weights}: \\texttt{ArgumentError} (bias correction not supported)\n",
       "\n",
       "\\end{itemize}\n"
      ],
      "text/markdown": [
       "```\n",
       "std(itr; corrected::Bool=true, mean=nothing[, dims])\n",
       "```\n",
       "\n",
       "Compute the sample standard deviation of collection `itr`.\n",
       "\n",
       "The algorithm returns an estimator of the generative distribution's standard deviation under the assumption that each entry of `itr` is an IID drawn from that generative distribution. For arrays, this computation is equivalent to calculating `sqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1))`. If `corrected` is `true`, then the sum is scaled with `n-1`, whereas the sum is scaled with `n` if `corrected` is `false` with `n` the number of elements in `itr`.\n",
       "\n",
       "A pre-computed `mean` may be provided.\n",
       "\n",
       "If `itr` is an `AbstractArray`, `dims` can be provided to compute the standard deviation over dimensions, and `means` may contain means for each dimension of `itr`.\n",
       "\n",
       "!!! note\n",
       "    If array contains `NaN` or [`missing`](@ref) values, the result is also `NaN` or `missing` (`missing` takes precedence if array contains both). Use the [`skipmissing`](@ref) function to omit `missing` entries and compute the standard deviation of non-missing values.\n",
       "\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "std(x::AbstractArray, w::AbstractWeights, [dim]; mean=nothing, corrected=false)\n",
       "```\n",
       "\n",
       "Compute the standard deviation of a real-valued array `x`, optionally over a dimension `dim`. Observations in `x` are weighted using weight vector `w`. The uncorrected (when `corrected=false`) sample standard deviation is defined as:\n",
       "\n",
       "$$\n",
       "\\sqrt{\\frac{1}{\\sum{w}} \\sum_{i=1}^n {w_i\\left({x_i - μ}\\right)^2 }}\n",
       "$$\n",
       "\n",
       "where $n$ is the length of the input and $μ$ is the mean. The unbiased estimate (when `corrected=true`) of the population standard deviation is computed by replacing $\\frac{1}{\\sum{w}}$ with a factor dependent on the type of weights used:\n",
       "\n",
       "  * `AnalyticWeights`: $\\frac{1}{\\sum w - \\sum {w^2} / \\sum w}$\n",
       "  * `FrequencyWeights`: $\\frac{1}{\\sum{w} - 1}$\n",
       "  * `ProbabilityWeights`: $\\frac{n}{(n - 1) \\sum w}$ where $n$ equals `count(!iszero, w)`\n",
       "  * `Weights`: `ArgumentError` (bias correction not supported)\n"
      ],
      "text/plain": [
       "\u001b[36m  std(itr; corrected::Bool=true, mean=nothing[, dims])\u001b[39m\n",
       "\n",
       "  Compute the sample standard deviation of collection \u001b[36mitr\u001b[39m.\n",
       "\n",
       "  The algorithm returns an estimator of the generative distribution's standard\n",
       "  deviation under the assumption that each entry of \u001b[36mitr\u001b[39m is an IID drawn from\n",
       "  that generative distribution. For arrays, this computation is equivalent to\n",
       "  calculating \u001b[36msqrt(sum((itr .- mean(itr)).^2) / (length(itr) - 1))\u001b[39m. If\n",
       "  \u001b[36mcorrected\u001b[39m is \u001b[36mtrue\u001b[39m, then the sum is scaled with \u001b[36mn-1\u001b[39m, whereas the sum is\n",
       "  scaled with \u001b[36mn\u001b[39m if \u001b[36mcorrected\u001b[39m is \u001b[36mfalse\u001b[39m with \u001b[36mn\u001b[39m the number of elements in \u001b[36mitr\u001b[39m.\n",
       "\n",
       "  A pre-computed \u001b[36mmean\u001b[39m may be provided.\n",
       "\n",
       "  If \u001b[36mitr\u001b[39m is an \u001b[36mAbstractArray\u001b[39m, \u001b[36mdims\u001b[39m can be provided to compute the standard\n",
       "  deviation over dimensions, and \u001b[36mmeans\u001b[39m may contain means for each dimension of\n",
       "  \u001b[36mitr\u001b[39m.\n",
       "\n",
       "\u001b[36m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[36m\u001b[1mNote\u001b[22m\u001b[39m\n",
       "\u001b[36m\u001b[1m  │\u001b[22m\u001b[39m\n",
       "\u001b[36m\u001b[1m  │\u001b[22m\u001b[39m  If array contains \u001b[36mNaN\u001b[39m or \u001b[36mmissing\u001b[39m values, the result is also \u001b[36mNaN\u001b[39m or\n",
       "\u001b[36m\u001b[1m  │\u001b[22m\u001b[39m  \u001b[36mmissing\u001b[39m (\u001b[36mmissing\u001b[39m takes precedence if array contains both). Use the\n",
       "\u001b[36m\u001b[1m  │\u001b[22m\u001b[39m  \u001b[36mskipmissing\u001b[39m function to omit \u001b[36mmissing\u001b[39m entries and compute the\n",
       "\u001b[36m\u001b[1m  │\u001b[22m\u001b[39m  standard deviation of non-missing values.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  std(x::AbstractArray, w::AbstractWeights, [dim]; mean=nothing, corrected=false)\u001b[39m\n",
       "\n",
       "  Compute the standard deviation of a real-valued array \u001b[36mx\u001b[39m, optionally over a\n",
       "  dimension \u001b[36mdim\u001b[39m. Observations in \u001b[36mx\u001b[39m are weighted using weight vector \u001b[36mw\u001b[39m. The\n",
       "  uncorrected (when \u001b[36mcorrected=false\u001b[39m) sample standard deviation is defined as:\n",
       "\n",
       "\u001b[35m\\sqrt{\\frac{1}{\\sum{w}} \\sum_{i=1}^n {w_i\\left({x_i - μ}\\right)^2 }}\u001b[39m\n",
       "\n",
       "  where \u001b[35mn\u001b[39m is the length of the input and \u001b[35mμ\u001b[39m is the mean. The unbiased estimate\n",
       "  (when \u001b[36mcorrected=true\u001b[39m) of the population standard deviation is computed by\n",
       "  replacing \u001b[35m\\frac{1}{\\sum{w}}\u001b[39m with a factor dependent on the type of weights\n",
       "  used:\n",
       "\n",
       "    •    \u001b[36mAnalyticWeights\u001b[39m: \u001b[35m\\frac{1}{\\sum w - \\sum {w^2} / \\sum w}\u001b[39m\n",
       "\n",
       "    •    \u001b[36mFrequencyWeights\u001b[39m: \u001b[35m\\frac{1}{\\sum{w} - 1}\u001b[39m\n",
       "\n",
       "    •    \u001b[36mProbabilityWeights\u001b[39m: \u001b[35m\\frac{n}{(n - 1) \\sum w}\u001b[39m where \u001b[35mn\u001b[39m equals\n",
       "        \u001b[36mcount(!iszero, w)\u001b[39m\n",
       "\n",
       "    •    \u001b[36mWeights\u001b[39m: \u001b[36mArgumentError\u001b[39m (bias correction not supported)"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sum_residuals_squared (generic function with 1 method)"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function sum_residuals_squared(observed_data, model_parameter)\n",
    "    x = observed_data[1] # vector\n",
    "    y = observed_data[2] # vector\n",
    "    \n",
    "    m = model_parameter[1] # slope, number\n",
    "    n = model_parameter[2] # offset, number\n",
    "    \n",
    "    ym = map(x -> m * x +n, x) # vector\n",
    "    \n",
    "    sqrt(sum((y .- ym) .^ 2))\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{AbstractArray{Float64,1},1}:\n",
       " 1.0:0.2:10.0\n",
       " [3.7901248951298667, 3.6616080841689342, 5.724566431570503, 5.008934351130017, 6.132903313802146, 7.1216386024985585, 5.9224001813739475, 7.176038011382015, 9.871017841081237, 9.954007033720487  …  23.387080045304963, 25.499068959556407, 26.74550582132148, 28.050987954892182, 26.802105459336726, 28.258703522038104, 30.449901895390262, 31.609368199131453, 32.245685449706656, 31.681125446643634]"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "observed_data = [t, y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " * Status: success\n",
       "\n",
       " * Candidate solution\n",
       "    Minimizer: [3.12e+00, 2.52e-01]\n",
       "    Minimum:   5.967764e+00\n",
       "\n",
       " * Found with\n",
       "    Algorithm:     Nelder-Mead\n",
       "    Initial Point: [1.00e+00, 0.00e+00]\n",
       "\n",
       " * Convergence measures\n",
       "    √(Σ(yᵢ-ȳ)²)/n ≤ 1.0e-08\n",
       "\n",
       " * Work counters\n",
       "    Seconds run:   0  (vs limit Inf)\n",
       "    Iterations:    46\n",
       "    f(x) calls:    89\n"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = optimize(p -> sum_residuals_squared(observed_data, p),  [1,0.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "1-element Array{PyCall.PyObject,1}:\n",
       " PyObject <matplotlib.lines.Line2D object at 0x7ff98c0b70d0>"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m,n = Optim.minimizer(res)\n",
    "\n",
    "scatter(t, y)\n",
    "plot(t, map(t-> m*t+n, t), color = \"red\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slope1 (generic function with 1 method)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function slope1()\n",
    "    t = 1:1.0:10\n",
    "    y = map(ti -> 3 * ti +1 + 4*randn(), t)\n",
    "    \n",
    "    v = [(y[i]-y[i-1])/(t[i]-t[i-1]) for i in 2:length(y)]\n",
    "    mean(v)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.353598002788559"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slope1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(mean(vs), std(vs)) = (2.998024670022978, 0.6295062186440472)\n"
     ]
    }
   ],
   "source": [
    "Random.seed!(1234)\n",
    "vs = [slope1() for i in 1:10000]\n",
    "\n",
    "@show mean(vs), std(vs);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slope2 (generic function with 1 method)"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function slope2()\n",
    "    t = 1:1.0:10\n",
    "    y = map(ti -> 3 * ti +1 + 4*randn(), t)\n",
    "    \n",
    "    observed_data = [t, y]\n",
    "    res = optimize(p -> sum_residuals_squared(observed_data, p),  [100.0,1.0])\n",
    "    m,s = Optim.minimizer(res)\n",
    "    m\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(mean(vs), std(vs)) = (3.0048218885588485, 0.44210310819240783)\n"
     ]
    }
   ],
   "source": [
    "Random.seed!(1234)\n",
    "vs = [slope2() for i in 1:10000]\n",
    "\n",
    "@show mean(vs), std(vs);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.4.2",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}