{ "cells": [ { "cell_type": "markdown", "id": "38805e6c", "metadata": {}, "source": [ "\n", "### Our goal\n", "\n", "Let's renew our acquaintance with the Python programming language, and begin to get to know the NumPy library and Jupyter notebooks.\n", "\n", "* Learn what kinds of vector arithmetic you can do\n", "with NumPy arrays.\n", "* Learn what kinds of functions NumPy provides for\n", "generating random numbers." ] }, { "cell_type": "markdown", "id": "b52aed69", "metadata": {}, "source": [ "### A parametric definition of a line\n", "\n", "Let's suppose that we have two distinct points in the plane:\n", "\n", "* Let $\\vec{p_0} = (x_0, y_0)$.\n", "* Let $\\vec{p_1} = (x_1, y_1)$.\n", "\n", "For all $t$ such that $0.0 \\leq t \\leq 1.0$ it is the case that the points returned by the function $\\vec{p}(t)$ lie on the line segment defined by $\\vec{p_0}$ and $\\vec{p_1}$:\n", "\n", "* $\\vec{p}(t) = \\vec{p_0} + t \\cdot (\\vec{p_1} - \\vec{p_0})$\n", "\n", "If $t < 0.0$ or $t > 1.0$, then $\\vec{p}(t)$ is a point on the line that passes through $\\vec{p_0}$ and $\\vec{p_1}$ but does not lie between those two points.\n" ] }, { "cell_type": "markdown", "id": "0d9c314a", "metadata": {}, "source": [ "### Exercise\n", "\n", "Write code that creates $N$ points on a line segment bounded by two points $(x_0, y_0)$ and $(x_1, y_1)$ and stores this data in a NumPy array.\n", "\n", "* Create a variable $N$. Assign to it any positive integer value that you choose.\n", "* Create variables to represent the coordinates of the two points. Assign to these variables values in the interval $[-1.0, +1.0]$. Select any values in that range that you like, so long as they define distinct points.\n", "* Write a loop to generate the points. Inside the loop, generate random values of the parameter $t$. Draw the values of $t$ from a uniform distribution of random numbers in the range $0.0$ to $1.0$.\n", "* Define function and write comments as appropriate to make concise, easy to understand code.\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "30590ca5", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# Here's how to get the numpy functions.\n", "import numpy as np\n", "\n", "# Here's how to get the pandas functions.\n", "import pandas as pd\n", "\n", "# Here's how to get the scikit-learn functions we need.\n", "from sklearn.linear_model import LinearRegression\n", "\n", "# Here's how to make it possible to draw plots in the notebook.\n", "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 16, "id": "192db9d8", "metadata": {}, "outputs": [], "source": [ "def makePoint(p0, p1):\n", " # Compute a distance.\n", " # This is will a fraction of the length\n", " # of the line segment defined by p0 and p1.\n", " t = np.random.random()\n", " \n", " # Here is a parametric representation of a line.\n", " p = p0 + t * (p1 - p0)\n", " \n", " # Here is a measure of how much we will move the point above\n", " # or below the line.\n", " stddev = 0.2\n", " \n", " # Here is a vector that points up or down.\n", " # Its length is random, with a specified\n", " # standard deviation.\n", " perturbation = np.array( [0.0, stddev * np.random.normal()] )\n", " \n", " # Return a point that lies a little above or \n", " # little below the line defined by p0 and p1.\n", " return p + perturbation" ] }, { "cell_type": "code", "execution_count": 17, "id": "2a5fd04b", "metadata": {}, "outputs": [], "source": [ "# Here's a function to make many points..\n", "\n", "def makePoints( p0, p1, numberOfPoints ): \n", " # Create a list of points.\n", " listOfPoints = [makePoint(p0,p1) for i in range(numberOfPoints)]\n", " \n", " # From the list create a NumPy array.\n", " return pd.DataFrame( listOfPoints, columns=['x', 'y'] )" ] }, { "cell_type": "code", "execution_count": 18, "id": "2d9a32a1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " x y\n", "0 3.307061 5.289125\n", "1 3.371959 4.935788\n", "2 1.247754 2.529217\n", "3 1.323632 2.628643\n", "4 3.815396 5.762297\n", ".. ... ...\n", "59 2.909116 4.528678\n", "60 2.504868 4.106989\n", "61 1.114532 2.388060\n", "62 1.647954 3.041494\n", "63 0.061244 1.200278\n", "\n", "[64 rows x 2 columns]\n" ] } ], "source": [ "# Specify how many points we will create.\n", "N = 64\n", "\n", "# Specify the coordinates of the 2 endpoints\n", "# of a line segment.\n", "p0 = np.array( [0.0, 1.0])\n", "p1 = np.array( [4.0, 6.0])\n", " \n", "# Make a collection of random points on or near\n", "# the line segment.\n", "data = makePoints(p0, p1, N)\n", "\n", "print( data )\n", " " ] }, { "cell_type": "code", "execution_count": 19, "id": "eb29b3be", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " x coordinates \n", "\n", " 3.3071\n", " 3.3720\n", " 1.2478\n", " 1.3236\n", " 3.8154\n", " 1.8913\n", " 0.9028\n", " 0.5533\n", " 3.3811\n", " 2.3290\n", " 2.8188\n", " 0.2837\n", " 3.9113\n", " 3.4046\n", " 2.0501\n", " 1.4046\n", " 0.5398\n", " 1.7989\n", " 3.3686\n", " 0.2473\n", " 3.5854\n", " 3.9565\n", " 3.8924\n", " 0.5675\n", " 0.7676\n", " 0.3348\n", " 1.5202\n", " 2.7248\n", " 1.9253\n", " 0.0580\n", " 0.6301\n", " 2.8616\n", " 3.3847\n", " 1.1157\n", " 1.2963\n", " 1.9330\n", " 0.3933\n", " 1.8583\n", " 0.4536\n", " 0.3129\n", " 0.7879\n", " 2.7787\n", " 1.3702\n", " 3.1795\n", " 2.3452\n", " 1.4434\n", " 3.7192\n", " 3.0273\n", " 0.3406\n", " 2.2918\n", " 3.3769\n", " 0.2565\n", " 0.7793\n", " 3.6825\n", " 1.6447\n", " 1.5110\n", " 3.8718\n", " 3.5003\n", " 3.0654\n", " 2.9091\n", " 2.5049\n", " 1.1145\n", " 1.6480\n", " 0.0612\n", "\n", " y coordinates \n", "\n", " 5.2891\n", " 4.9358\n", " 2.5292\n", " 2.6286\n", " 5.7623\n", " 3.3760\n", " 2.0016\n", " 2.0526\n", " 5.1084\n", " 4.0567\n", " 4.1273\n", " 1.2100\n", " 5.7878\n", " 5.4829\n", " 3.9235\n", " 3.0276\n", " 1.8760\n", " 3.3052\n", " 5.0793\n", " 1.1784\n", " 5.4726\n", " 5.8750\n", " 6.0649\n", " 1.6361\n", " 1.6599\n", " 1.8335\n", " 2.7205\n", " 4.2185\n", " 3.6952\n", " 1.3605\n", " 1.6981\n", " 4.5097\n", " 5.3101\n", " 2.2440\n", " 2.3680\n", " 3.8941\n", " 1.5884\n", " 3.1321\n", " 1.6173\n", " 1.5748\n", " 2.0201\n", " 4.2438\n", " 2.6545\n", " 5.2480\n", " 4.0918\n", " 2.4220\n", " 5.5589\n", " 4.8063\n", " 1.6124\n", " 3.9589\n", " 4.9128\n", " 1.1025\n", " 1.9028\n", " 5.5061\n", " 3.0991\n", " 3.1157\n", " 5.8199\n", " 5.2113\n", " 4.5394\n", " 4.5287\n", " 4.1070\n", " 2.3881\n", " 3.0415\n", " 1.2003\n" ] } ], "source": [ "\n", "x = data['x']\n", "y = data['y']\n", "\n", "print( '\\n x coordinates \\n' )\n", "\n", "for coordinate in x:\n", " print( f'{coordinate:8.4f}' )\n", "\n", "print( '\\n y coordinates \\n' )\n", "\n", "for coordinate in y:\n", " print( f'{coordinate:8.4f}' )" ] }, { "cell_type": "code", "execution_count": 20, "id": "5cb4933d", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "\n", "\n", "plt.scatter( x, y )\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 34, "id": "18763caf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "(64, 1)\n", "(64, 1)\n" ] } ], "source": [ "# Construct an instance of the LinearRegression class.\n", "linearRegression = LinearRegression()\n", "\n", "# Put columns of the DataFrame into numpy arrays.\n", "xCoordinates = x.to_numpy()\n", "yCoordinates = y.to_numpy()\n", "\n", "xCoordinates = xCoordinates.reshape(-1,1)\n", "yCoordinates = yCoordinates.reshape(-1,1)\n", "\n", "# Take a look at the types of the data structures.\n", "print( type(xCoordinates) )\n", "print( type(yCoordinates) )\n", "\n", "# Take a look at the shape of the numpy arrays.\n", "print( xCoordinates.shape )\n", "print( yCoordinates.shape )\n", "\n", "# Compute the slope and intercept of the line\n", "# that best fits the points.\n", "bestLine = linearRegression.fit( xCoordinates, yCoordinates )\n", "\n" ] }, { "cell_type": "code", "execution_count": 48, "id": "2568283f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " Types of m and b. \n", "\n", "\n", "\n", "\n", " Shapes of m and b. \n", "\n", "(1, 1)\n", "(1,)\n", "\n", " Types of m and b. \n", "\n", "\n", "\n", "\n", "\n", "slope = 1.2206\n", "y intercept = 1.0565\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Following the usual convention, let's call the slope m\n", "# and the y intercept b.\n", "m = bestLine.coef_\n", "b = bestLine.intercept_\n", "\n", "print( '\\n Types of m and b. \\n')\n", "print( type(m) )\n", "print( type(b) )\n", "\n", "print( '\\n Shapes of m and b. \\n' )\n", "print( m.shape )\n", "print( b.shape )\n", "\n", "m = m[0,0]\n", "b = b[0]\n", "\n", "print( '\\n Types of m and b. \\n')\n", "print( type(m) )\n", "print( type(b) )\n", "\n", "print( '\\n' )\n", "print( f'slope = {m:8.4f}' )\n", "print( f'y intercept = {b:8.4f}' )\n", "\n", "# Specify the x coordinates of\n", "# 2 points on the best-fitting line.\n", "u = np.array( [0.0, 4.0] )\n", "\n", "# Compute the y coordinates of those\n", "# 2 points on the best-fitting line.\n", "v = m * u + b\n", "\n", "# Plot the data points.\n", "plt.scatter( x, y )\n", "\n", "# Plot the line that best fits the data points.\n", "plt.plot( u, v, 'r' )\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "22f6d8b9", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "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.3" } }, "nbformat": 4, "nbformat_minor": 5 }