"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "utils.plot_transformation(lambda v: T_rotation_and_stretch(np.pi, 2, v), e1,e2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3 - Neural Networks\n",
+ "\n",
+ "\n",
+ "In this part of the assignment you will: \n",
+ "\n",
+ "- Implement a neural network with a single perceptron and two input nodes for linear regression\n",
+ "- Implement forward propagation using matrix multiplication\n",
+ "\n",
+ "\n",
+ "*Note*: Backward propagation with the parameters update requires understanding of Calculus. It is discussed in details in the Course \"Calculus\" (Course 2 in the Specialization \"Mathematics for Machine Learning\"). In this assignment backward propagation and parameters update functions are hidden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.1 - Linear Regression\n",
+ "\n",
+ "\n",
+ "**Linear regression** is a linear approach for modelling the relationship between a scalar response (**dependent variable**) and one or more explanatory variables (**independent variables**). You will work with a linear regression with $2$ independent variables.\n",
+ "\n",
+ "Linear regression model with two independent variables $x_1$, $x_2$ can be written as\n",
+ "\n",
+ "$$\\hat{y} = w_1x_1 + w_2x_2 + b = Wx + b,\\tag{6}$$\n",
+ "\n",
+ "where $Wx$ is the dot product of the input vector $x = \\begin{bmatrix} x_1 & x_2\\end{bmatrix}$ and parameters vector $W = \\begin{bmatrix} w_1 & w_2\\end{bmatrix}$, scalar parameter $b$ is the intercept. \n",
+ "\n",
+ "The goal is the same - find the \"best\" parameters $w_1$, $w_2$ and $b$ such the differences between original values $y_i$ and predicted values $\\hat{y}_i$ are minimum.\n",
+ "\n",
+ "You can use a neural network model to do that. Matrix multiplication will be in the core of the model!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.2 - Neural Network Model with a Single Perceptron and Two Input Nodes\n",
+ "\n",
+ "Again, you will use only one perceptron, but with two input nodes shown in the following scheme:\n",
+ "\n",
+ "\n",
+ "\n",
+ "The perceptron output calculation for a training example $x = \\begin{bmatrix} x_1& x_2\\end{bmatrix}$ can be written with dot product:\n",
+ "\n",
+ "$$z = w_1x_1 + w_2x_2+ b = Wx + b$$\n",
+ "\n",
+ "where weights are in the vector $W = \\begin{bmatrix} w_1 & w_2\\end{bmatrix}$ and bias $b$ is a scalar. The output layer will have the same single node $\\hat{y}= z$.\n",
+ "\n",
+ "Organise all training examples in a matrix $X$ of a shape ($2 \\times m$), putting $x_1$ and $x_2$ into columns. Then matrix multiplication of $W$ ($1 \\times 2$) and $X$ ($2 \\times m$) will give a ($1 \\times m$) vector\n",
+ "\n",
+ "$$WX = \n",
+ "\\begin{bmatrix} w_1 & w_2\\end{bmatrix} \n",
+ "\\begin{bmatrix} \n",
+ "x_1^{(1)} & x_1^{(2)} & \\dots & x_1^{(m)} \\\\ \n",
+ "x_2^{(1)} & x_2^{(2)} & \\dots & x_2^{(m)} \\\\ \\end{bmatrix}\n",
+ "=\\begin{bmatrix} \n",
+ "w_1x_1^{(1)} + w_2x_2^{(1)} & \n",
+ "w_1x_1^{(2)} + w_2x_2^{(2)} & \\dots & \n",
+ "w_1x_1^{(m)} + w_2x_2^{(m)}\\end{bmatrix}.$$\n",
+ "\n",
+ "And the model can be written as\n",
+ "\n",
+ "\\begin{align}\n",
+ "Z &= W X + b,\\\\\n",
+ "\\hat{Y} &= Z,\n",
+ "\\tag{8}\\end{align}\n",
+ "\n",
+ "where $b$ is broadcasted to the vector of a size ($1 \\times m$). These are the calculations to perform in the forward propagation step.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, you can compare the resulting vector of the predictions $\\hat{Y}$ ($1 \\times m$) with the original vector of data $Y$. This can be done with the so called **cost function** that measures how close your vector of predictions is to the training data. It evaluates how well the parameters $w$ and $b$ work to solve the problem. There are many different cost functions available depending on the nature of your problem. For your simple neural network you can calculate it as:\n",
+ "\n",
+ "$$\\mathcal{L}\\left(w, b\\right) = \\frac{1}{2m}\\sum_{i=1}^{m} \\left(\\hat{y}^{(i)} - y^{(i)}\\right)^2.\\tag{5}$$\n",
+ "\n",
+ "The aim is to minimize the cost function during the training, which will minimize the differences between original values $y_i$ and predicted values $\\hat{y}_i$ (division by $2m$ is taken just for scaling purposes).\n",
+ "\n",
+ "When your weights were just initialized with some random values, and no training was done yet, you can't expect good results.\n",
+ "\n",
+ "The next step is to adjust the weights and bias, in order to minimize the cost function. This process is called **backward propagation** and is done iteratively: you update the parameters with a small change and repeat the process.\n",
+ "\n",
+ "*Note*: Backward propagation is not covered in this Course - it will be discussed in the next Course of this Specialization.\n",
+ "\n",
+ "The general **methodology** to build a neural network is to:\n",
+ "1. Define the neural network structure ( # of input units, # of hidden units, etc). \n",
+ "2. Initialize the model's parameters\n",
+ "3. Loop:\n",
+ " - Implement forward propagation (calculate the perceptron output),\n",
+ " - Implement backward propagation (to get the required corrections for the parameters),\n",
+ " - Update parameters.\n",
+ "4. Make predictions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.3 Parameters of the Neural Network\n",
+ "\n",
+ "The neural network you will be working with has $3$ parameters. Two weights and one bias, you will start initalizing these parameters as some random numbers, so the algorithm can start at some point. The parameters will be stored in a dictionary."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'W': array([[ 0.0064941 , -0.01006149]]), 'b': array([[0.]])}\n"
+ ]
+ }
+ ],
+ "source": [
+ "parameters = utils.initialize_parameters(2)\n",
+ "print(parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.4 Forward propagation\n",
+ "\n",
+ "\n",
+ "### Exercise 5\n",
+ "\n",
+ "Implement `forward_propagation()`.\n",
+ "\n",
+ "**Instructions**:\n",
+ "- Look at the mathematical representation of your model:\n",
+ "\\begin{align}\n",
+ "Z &= W X + b\\\\\n",
+ "\\hat{Y} &= Z,\n",
+ "\\end{align}\n",
+ "- The steps you have to implement are:\n",
+ " 1. Retrieve each parameter from the dictionary \"parameters\" by using `parameters[\"..\"]`.\n",
+ " 2. Implement Forward Propagation. Compute `Z` multiplying arrays `W`, `X` and adding vector `b`. Set the prediction array $A$ equal to $Z$. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# GRADED FUNCTION: forward_propagation\n",
+ "\n",
+ "def forward_propagation(X, parameters):\n",
+ " \"\"\"\n",
+ " Argument:\n",
+ " X -- input data of size (n_x, m), where n_x is the dimension input (in our example is 2) and m is the number of training samples\n",
+ " parameters -- python dictionary containing your parameters (output of initialization function)\n",
+ " \n",
+ " Returns:\n",
+ " Y_hat -- The output of size (1, m)\n",
+ " \"\"\"\n",
+ " # Retrieve each parameter from the dictionary \"parameters\".\n",
+ " W = parameters[\"W\"]\n",
+ " b = parameters[\"b\"]\n",
+ " \n",
+ " # Implement Forward Propagation to calculate Z.\n",
+ " ### START CODE HERE ### (~ 2 lines of code)\n",
+ " Z = W@X + b\n",
+ " Y_hat = Z\n",
+ " ### END CODE HERE ###\n",
+ " \n",
+ "\n",
+ " return Y_hat"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[92m All tests passed\n"
+ ]
+ }
+ ],
+ "source": [
+ "w3_unittest.test_forward_propagation(forward_propagation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.5 Defining the cost function\n",
+ "\n",
+ "The cost function used to traing this model is \n",
+ "\n",
+ "$$\\mathcal{L}\\left(w, b\\right) = \\frac{1}{2m}\\sum_{i=1}^{m} \\left(\\hat{y}^{(i)} - y^{(i)}\\right)^2$$\n",
+ "\n",
+ "The next implementation is not graded."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "def compute_cost(Y_hat, Y):\n",
+ " \"\"\"\n",
+ " Computes the cost function as a sum of squares\n",
+ " \n",
+ " Arguments:\n",
+ " Y_hat -- The output of the neural network of shape (n_y, number of examples)\n",
+ " Y -- \"true\" labels vector of shape (n_y, number of examples)\n",
+ " \n",
+ " Returns:\n",
+ " cost -- sum of squares scaled by 1/(2*number of examples)\n",
+ " \n",
+ " \"\"\"\n",
+ " # Number of examples.\n",
+ " m = Y.shape[1]\n",
+ "\n",
+ " # Compute the cost function.\n",
+ " cost = np.sum((Y_hat - Y)**2)/(2*m)\n",
+ " \n",
+ " return cost"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### Exercise 6\n",
+ "\n",
+ "Now you're ready to implement your neural network. The next function will implement the training process and it will return the updated parameters dictionary where you will be able to make predictions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# GRADED FUNCTION: nn_model\n",
+ "\n",
+ "def nn_model(X, Y, num_iterations=1000, print_cost=False):\n",
+ " \"\"\"\n",
+ " Arguments:\n",
+ " X -- dataset of shape (n_x, number of examples)\n",
+ " Y -- labels of shape (1, number of examples)\n",
+ " num_iterations -- number of iterations in the loop\n",
+ " print_cost -- if True, print the cost every iteration\n",
+ " \n",
+ " Returns:\n",
+ " parameters -- parameters learnt by the model. They can then be used to make predictions.\n",
+ " \"\"\"\n",
+ " \n",
+ " n_x = X.shape[0]\n",
+ " \n",
+ " # Initialize parameters\n",
+ " parameters = utils.initialize_parameters(n_x) \n",
+ " \n",
+ " # Loop\n",
+ " for i in range(0, num_iterations):\n",
+ " \n",
+ " ### START CODE HERE ### (~ 2 lines of code)\n",
+ " # Forward propagation. Inputs: \"X, parameters, n_y\". Outputs: \"Y_hat\".\n",
+ " Y_hat = forward_propagation(X, parameters)\n",
+ " \n",
+ " # Cost function. Inputs: \"Y_hat, Y\". Outputs: \"cost\".\n",
+ " cost = compute_cost(Y_hat, Y)\n",
+ " ### END CODE HERE ###\n",
+ " \n",
+ " \n",
+ " # Parameters update.\n",
+ " parameters = utils.train_nn(parameters, Y_hat, X, Y, learning_rate = 0.001) \n",
+ " \n",
+ " # Print the cost every iteration.\n",
+ " if print_cost:\n",
+ " if i%100 == 0:\n",
+ " print (\"Cost after iteration %i: %f\" %(i, cost))\n",
+ "\n",
+ " return parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[92m All tests passed\n"
+ ]
+ }
+ ],
+ "source": [
+ "w3_unittest.test_nn_model(nn_model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.6 - Training the neural network\n",
+ "\n",
+ "Now let's load a dataset to train the neural network."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "df = pd.read_csv(\"data/toy_dataset.csv\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
x1
\n",
+ "
x2
\n",
+ "
y
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
-0.816777
\n",
+ "
-0.524620
\n",
+ "
-0.940299
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
-0.670257
\n",
+ "
1.525658
\n",
+ "
0.754702
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
-0.163599
\n",
+ "
0.268567
\n",
+ "
0.034551
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
2.141420
\n",
+ "
0.428381
\n",
+ "
1.802543
\n",
+ "
\n",
+ "
\n",
+ "
4
\n",
+ "
0.163608
\n",
+ "
0.257243
\n",
+ "
0.314790
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " x1 x2 y\n",
+ "0 -0.816777 -0.524620 -0.940299\n",
+ "1 -0.670257 1.525658 0.754702\n",
+ "2 -0.163599 0.268567 0.034551\n",
+ "3 2.141420 0.428381 1.802543\n",
+ "4 0.163608 0.257243 0.314790"
+ ]
+ },
+ "execution_count": 44,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's first turn the data into a numpy array to pass it to the our function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "X = np.array(df[['x1','x2']]).T\n",
+ "Y = np.array(df['y']).reshape(1,-1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Run the next block to update the parameters dictionary with the fitted weights."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Cost after iteration 0: 0.496618\n",
+ "Cost after iteration 100: 0.409979\n",
+ "Cost after iteration 200: 0.338492\n",
+ "Cost after iteration 300: 0.279508\n",
+ "Cost after iteration 400: 0.230839\n",
+ "Cost after iteration 500: 0.190682\n",
+ "Cost after iteration 600: 0.157548\n",
+ "Cost after iteration 700: 0.130208\n",
+ "Cost after iteration 800: 0.107650\n",
+ "Cost after iteration 900: 0.089037\n",
+ "Cost after iteration 1000: 0.073679\n",
+ "Cost after iteration 1100: 0.061007\n",
+ "Cost after iteration 1200: 0.050551\n",
+ "Cost after iteration 1300: 0.041923\n",
+ "Cost after iteration 1400: 0.034805\n",
+ "Cost after iteration 1500: 0.028931\n",
+ "Cost after iteration 1600: 0.024084\n",
+ "Cost after iteration 1700: 0.020086\n",
+ "Cost after iteration 1800: 0.016786\n",
+ "Cost after iteration 1900: 0.014063\n",
+ "Cost after iteration 2000: 0.011817\n",
+ "Cost after iteration 2100: 0.009963\n",
+ "Cost after iteration 2200: 0.008434\n",
+ "Cost after iteration 2300: 0.007172\n",
+ "Cost after iteration 2400: 0.006131\n",
+ "Cost after iteration 2500: 0.005272\n",
+ "Cost after iteration 2600: 0.004563\n",
+ "Cost after iteration 2700: 0.003978\n",
+ "Cost after iteration 2800: 0.003495\n",
+ "Cost after iteration 2900: 0.003097\n",
+ "Cost after iteration 3000: 0.002768\n",
+ "Cost after iteration 3100: 0.002497\n",
+ "Cost after iteration 3200: 0.002273\n",
+ "Cost after iteration 3300: 0.002089\n",
+ "Cost after iteration 3400: 0.001936\n",
+ "Cost after iteration 3500: 0.001811\n",
+ "Cost after iteration 3600: 0.001707\n",
+ "Cost after iteration 3700: 0.001621\n",
+ "Cost after iteration 3800: 0.001551\n",
+ "Cost after iteration 3900: 0.001493\n",
+ "Cost after iteration 4000: 0.001444\n",
+ "Cost after iteration 4100: 0.001405\n",
+ "Cost after iteration 4200: 0.001372\n",
+ "Cost after iteration 4300: 0.001345\n",
+ "Cost after iteration 4400: 0.001323\n",
+ "Cost after iteration 4500: 0.001304\n",
+ "Cost after iteration 4600: 0.001289\n",
+ "Cost after iteration 4700: 0.001277\n",
+ "Cost after iteration 4800: 0.001266\n",
+ "Cost after iteration 4900: 0.001258\n"
+ ]
+ }
+ ],
+ "source": [
+ "parameters = nn_model(X,Y, num_iterations = 5000, print_cost= True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4 - Make your predictions!\n",
+ "\n",
+ "Now that you have the fitted parameters, you are able to predict any value with your neural network! You just need to perform the following computation:\n",
+ "\n",
+ "$$ Z = W X + b$$ \n",
+ "\n",
+ "Where $W$ and $b$ are in the parameters dictionary.\n",
+ "\n",
+ "\n",
+ "### Exercise 7\n",
+ "\n",
+ "Now you will make the predictor function. It will input a parameters dictionary, a set of points X and output the set of predicted values. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# GRADED FUNCTION: predict\n",
+ "\n",
+ "def predict(X, parameters):\n",
+ "\n",
+ " W = parameters['W']\n",
+ " b = parameters['b']\n",
+ "\n",
+ " Z = np.dot(W, X) + b\n",
+ "\n",
+ " return Z"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "y_hat = predict(X,parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "df['y_hat'] = y_hat[0]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now let's check some predicted values versus the original ones:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(x1,x2) = (-0.82, -0.52): Actual value: -0.94. Predicted value: -0.95\n",
+ "(x1,x2) = (-0.67, 1.53): Actual value: 0.75. Predicted value: 0.68\n",
+ "(x1,x2) = (-0.16, 0.27): Actual value: 0.03. Predicted value: 0.09\n",
+ "(x1,x2) = (2.14, 0.43): Actual value: 1.80. Predicted value: 1.78\n",
+ "(x1,x2) = (0.16, 0.26): Actual value: 0.31. Predicted value: 0.30\n",
+ "(x1,x2) = (-0.80, 2.07): Actual value: 1.12. Predicted value: 0.99\n",
+ "(x1,x2) = (-2.64, -1.36): Actual value: -2.85. Predicted value: -2.82\n",
+ "(x1,x2) = (1.04, -0.38): Actual value: 0.45. Predicted value: 0.43\n",
+ "(x1,x2) = (0.15, 0.19): Actual value: 0.25. Predicted value: 0.25\n",
+ "(x1,x2) = (-1.57, -0.34): Actual value: -1.31. Predicted value: -1.33\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(10):\n",
+ " print(f\"(x1,x2) = ({df.loc[i,'x1']:.2f}, {df.loc[i,'x2']:.2f}): Actual value: {df.loc[i,'y']:.2f}. Predicted value: {df.loc[i,'y_hat']:.2f}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Pretty good, right? Congratulations! You have finished the W3 assignment!"
+ ]
+ }
+ ],
+ "metadata": {
+ "grader_version": "1",
+ "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.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/C1W3_Linear_Transformation.ipynb b/C1W3_Linear_Transformation.ipynb
new file mode 100644
index 0000000..7027083
--- /dev/null
+++ b/C1W3_Linear_Transformation.ipynb
@@ -0,0 +1,1069 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EAt-K2qgcIou"
+ },
+ "source": [
+ "# Linear Transformations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FZYK-0rin5x7"
+ },
+ "source": [
+ "In this lab you will explore linear transformations, visualize their results and master matrix multiplication to apply various linear transformations."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Table of Contents\n",
+ "- [ 1 - Transformations](#1)\n",
+ "- [ 2 - Linear Transformations](#2)\n",
+ "- [ 3 - Transformations Defined as a Matrix Multiplication](#3)\n",
+ "- [ 4 - Standard Transformations in a Plane](#4)\n",
+ " - [ 4.1 - Example 1: Horizontal Scaling (Dilation)](#4.1)\n",
+ " - [ 4.2 - Example 2: Reflection about y-axis (the vertical axis)](#4.2)\n",
+ "- [ 5 - Application of Linear Transformations: Computer Graphics](#5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XI8PBrk_2Z4V"
+ },
+ "source": [
+ "## Packages\n",
+ "\n",
+ "Run the following cell to load the package you'll need."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "# OpenCV library for image transformations.\n",
+ "import cv2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1 - Transformations\n",
+ "\n",
+ "A **transformation** is a function from one vector space to another that respects the underlying (linear) structure of each vector space. Referring to a specific transformation, you can use a symbol, such as $T$. Specifying the spaces containing the input and output vectors, e.g. $\\mathbb{R}^2$ and $\\mathbb{R}^3$, you can write $T: \\mathbb{R}^2 \\rightarrow \\mathbb{R}^3$. Transforming vector $v \\in \\mathbb{R}^2$ into the vector $w\\in\\mathbb{R}^3$ by the transformation $T$, you can use the notation $T(v)=w$ and read it as \"*T of v equals to w*\" or \"*vector w is an **image** of vector v with the transformation T*\".\n",
+ "\n",
+ "The following Python function corresponds to the transformation $T: \\mathbb{R}^2 \\rightarrow \\mathbb{R}^3$ with the following symbolic formula:\n",
+ "\n",
+ "$$T\\begin{pmatrix}\n",
+ " \\begin{bmatrix}\n",
+ " v_1 \\\\ \n",
+ " v_2\n",
+ " \\end{bmatrix}\\end{pmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " 3v_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2v_2\n",
+ " \\end{bmatrix}\n",
+ " \\tag{1}\n",
+ " $$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "id": "Je3yV0Wnn5x8",
+ "scrolled": true,
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original vector:\n",
+ " [[3]\n",
+ " [5]] \n",
+ "\n",
+ " Result of the transformation:\n",
+ " [[ 9.]\n",
+ " [ 0.]\n",
+ " [-10.]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def T(v):\n",
+ " w = np.zeros((3,1))\n",
+ " w[0,0] = 3*v[0,0]\n",
+ " w[2,0] = -2*v[1,0]\n",
+ " \n",
+ " return w\n",
+ "\n",
+ "v = np.array([[3], [5]])\n",
+ "w = T(v)\n",
+ "\n",
+ "print(\"Original vector:\\n\", v, \"\\n\\n Result of the transformation:\\n\", w)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "v3=np.array([[5,4],[6,2]])\n",
+ "w=T(v3)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[ 15.]\n",
+ " [ 0.]\n",
+ " [-12.]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(w)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2 - Linear Transformations\n",
+ "\n",
+ "A transformation $T$ is said to be **linear** if the following two properties are true for any scalar $k$, and any input vectors $u$ and $v$:\n",
+ "\n",
+ "1. $T(kv)=kT(v)$,\n",
+ "2. $T(u+v)=T(u)+T(v)$.\n",
+ "\n",
+ "In the example above $T$ is a linear transformation:\n",
+ "\n",
+ "$$T (kv) =\n",
+ " T \\begin{pmatrix}\\begin{bmatrix}\n",
+ " kv_1 \\\\\n",
+ " kv_2\n",
+ " \\end{bmatrix}\\end{pmatrix} = \n",
+ " \\begin{bmatrix}\n",
+ " 3kv_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2kv_2\n",
+ " \\end{bmatrix} =\n",
+ " k\\begin{bmatrix}\n",
+ " 3v_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2v_2\n",
+ " \\end{bmatrix} = \n",
+ " kT(v),\\tag{2}$$\n",
+ " \n",
+ "$$T (u+v) =\n",
+ " T \\begin{pmatrix}\\begin{bmatrix}\n",
+ " u_1 + v_1 \\\\\n",
+ " u_2 + v_2\n",
+ " \\end{bmatrix}\\end{pmatrix} = \n",
+ " \\begin{bmatrix}\n",
+ " 3(u_1+v_1) \\\\\n",
+ " 0 \\\\\n",
+ " -2(u_2+v_2)\n",
+ " \\end{bmatrix} = \n",
+ " \\begin{bmatrix}\n",
+ " 3u_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2u_2\n",
+ " \\end{bmatrix} +\n",
+ " \\begin{bmatrix}\n",
+ " 3v_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2v_2\n",
+ " \\end{bmatrix} = \n",
+ " T(u)+T(v).\\tag{3}$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can change the values of $k$ or vectors $u$ and $v$ in the cell below, to check that this is true for some specific values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "T(k*v):\n",
+ " [[ 42.]\n",
+ " [ 0.]\n",
+ " [-56.]] \n",
+ " k*T(v):\n",
+ " [[ 42.]\n",
+ " [ 0.]\n",
+ " [-56.]] \n",
+ "\n",
+ "\n",
+ "T(u+v):\n",
+ " [[ 9.]\n",
+ " [ 0.]\n",
+ " [-4.]] \n",
+ " T(u)+T(v):\n",
+ " [[ 9.]\n",
+ " [ 0.]\n",
+ " [-4.]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "u = np.array([[1], [-2]])\n",
+ "v = np.array([[2], [4]])\n",
+ "\n",
+ "k = 7\n",
+ "\n",
+ "print(\"T(k*v):\\n\", T(k*v), \"\\n k*T(v):\\n\", k*T(v), \"\\n\\n\")\n",
+ "print(\"T(u+v):\\n\", T(u+v), \"\\n T(u)+T(v):\\n\", T(u)+T(v))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Some examples of linear transformations are rotations, reflections, scaling (dilations), etc. In this lab you will explore a few of them."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3 - Transformations Defined as a Matrix Multiplication\n",
+ "\n",
+ "Let $L: \\mathbb{R}^m \\rightarrow \\mathbb{R}^n$ be defined by a matrix $A$, where $L(v)=Av$, multiplication of the matrix $A$ ($n\\times m$) and vector $v$ ($m\\times 1$) resulting in the vector $w$ ($n\\times 1$).\n",
+ "\n",
+ "Now try to guess, what should be the elements of matrix $A$, corresponding to the transformation $L: \\mathbb{R}^2 \\rightarrow \\mathbb{R}^3$:\n",
+ "\n",
+ "$$L\\begin{pmatrix}\n",
+ " \\begin{bmatrix}\n",
+ " v_1 \\\\ \n",
+ " v_2\n",
+ " \\end{bmatrix}\\end{pmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " 3v_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2v_2\n",
+ " \\end{bmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " ? & ? \\\\\n",
+ " ? & ? \\\\\n",
+ " ? & ?\n",
+ " \\end{bmatrix}\n",
+ " \\begin{bmatrix}\n",
+ " v_1 \\\\\n",
+ " v_2\n",
+ " \\end{bmatrix}\n",
+ " \\tag{4}\n",
+ " $$\n",
+ "\n",
+ "To do that, write the transformation $L$ as $Av$ and then perform matrix multiplication:\n",
+ " $$L\\begin{pmatrix}\n",
+ " \\begin{bmatrix}\n",
+ " v_1 \\\\ \n",
+ " v_2\n",
+ " \\end{bmatrix}\\end{pmatrix}=\n",
+ " A\\begin{bmatrix}\n",
+ " v_1 \\\\ \n",
+ " v_2\n",
+ " \\end{bmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " a_{1,1} & a_{1,2} \\\\\n",
+ " a_{2,1} & a_{2,2} \\\\\n",
+ " a_{3,1} & a_{3,2}\n",
+ " \\end{bmatrix}\n",
+ " \\begin{bmatrix}\n",
+ " v_1 \\\\ \n",
+ " v_2\n",
+ " \\end{bmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " a_{1,1}v_1+a_{1,2}v_2 \\\\\n",
+ " a_{2,1}v_1+a_{2,2}v_2 \\\\\n",
+ " a_{3,1}v_1+a_{3,2}v_2 \\\\\n",
+ " \\end{bmatrix}=\n",
+ " \\begin{bmatrix}\n",
+ " 3v_1 \\\\\n",
+ " 0 \\\\\n",
+ " -2v_2\n",
+ " \\end{bmatrix}\\tag{5}\n",
+ " $$\n",
+ " \n",
+ "Can you see now what should be the values of the elements $a_{i,j}$ of matrix $A$ to make the equalities $(5)$ correct? Find out the answer in the following code cell:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Transformation matrix:\n",
+ " [[ 3 0]\n",
+ " [ 0 0]\n",
+ " [ 0 -2]] \n",
+ "\n",
+ "Original vector:\n",
+ " [[3]\n",
+ " [5]] \n",
+ "\n",
+ " Result of the transformation:\n",
+ " [[ 9]\n",
+ " [ 0]\n",
+ " [-10]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def L(v):\n",
+ " A = np.array([[3,0], [0,0], [0,-2]])\n",
+ " print(\"Transformation matrix:\\n\", A, \"\\n\")\n",
+ " w = A @ v\n",
+ " \n",
+ " return w\n",
+ "\n",
+ "v = np.array([[3], [5]])\n",
+ "w = L(v)\n",
+ "\n",
+ "print(\"Original vector:\\n\", v, \"\\n\\n Result of the transformation:\\n\", w)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Every linear transformation can be carried out by matrix multiplication. And vice versa, carrying out matrix multiplication, it is natural to consider the linear transformation that it represents. It means you can associate the matrix with the linear transformation in some way. This is a key connection between linear transformations and matrix algebra."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 4 - Standard Transformations in a Plane\n",
+ "\n",
+ "As discussed above in section [3](#3), a linear transformation $L: \\mathbb{R}^2 \\rightarrow \\mathbb{R}^2$ can be represented as a multiplication of a $2 \\times 2$ matrix and a coordinate vector $v\\in\\mathbb{R}^2.$ Note that so far you have been using some random vector $v\\in\\mathbb{R}^2.$ (e.g. $v=\\begin{bmatrix}3 \\\\ 5\\end{bmatrix}$). To have a better intuition of what the transformation is really doing in the $\\mathbb{R}^2$ space, it is wise to choose vector $v$ in a less random way. \n",
+ "\n",
+ "A good choice would be vectors of a standard basis $e_1=\\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$ and $e_2=\\begin{bmatrix}0 \\\\ 1\\end{bmatrix}$. Let's apply linear transformation $L$ to each of the vectors $e_1$ and $e_2$: $L(e_1)=Ae_1$ and $L(e_2)=Ae_2$. If you put vectors $\\{e_1, e_2\\}$ into columns of a matrix and perform matrix multiplication\n",
+ "\n",
+ "$$A\\begin{bmatrix}e_1 & e_2\\end{bmatrix}=\\begin{bmatrix}Ae_1 & Ae_2\\end{bmatrix}=\\begin{bmatrix}L(e_1) & L(e_2)\\end{bmatrix},\\tag{3}$$\n",
+ "\n",
+ "you can note that $\\begin{bmatrix}e_1 & e_2\\end{bmatrix}=\\begin{bmatrix}1 & 0 \\\\ 0 & 1\\end{bmatrix}$ (identity matrix). Thus, $A\\begin{bmatrix}e_1 & e_2\\end{bmatrix} = AI=A$, and\n",
+ "\n",
+ "$$A=\\begin{bmatrix}L(e_1) & L(e_2)\\end{bmatrix}.\\tag{4}$$\n",
+ "\n",
+ "This is a matrix with the columns that are the images of the vectors of the standard basis. \n",
+ "\n",
+ "This choice of vectors \\{$e_1, e_2$\\} provides opportinuty for the visual representation of the linear transformation $L$ (you will see the examples below)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 4.1 - Example 1: Horizontal Scaling (Dilation)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Horizontal scaling (factor $2$ in this example) can be defined considering transformation of a vector $e_1=\\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$ into a vector $\\begin{bmatrix}2 \\\\ 0\\end{bmatrix}$ and leaving vector $e_2=\\begin{bmatrix}0 \\\\ 1\\end{bmatrix}$ without any changes. The following function `T_hscaling()` corresponds to the horizontal scaling (factor $2$) of a vector. The second function `transform_vectors()` applies defined transformation to a set of vectors (here two vectors)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original vectors:\n",
+ " e1= \n",
+ " [[1]\n",
+ " [0]] \n",
+ " e2=\n",
+ " [[0]\n",
+ " [1]] \n",
+ "\n",
+ " Result of the transformation (matrix form):\n",
+ " [[2 0]\n",
+ " [0 1]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def T_hscaling(v):\n",
+ " A = np.array([[2,0], [0,1]])\n",
+ " w = A @ v\n",
+ " \n",
+ " return w\n",
+ " \n",
+ " \n",
+ "def transform_vectors(T, v1, v2):\n",
+ " V = np.hstack((v1, v2))\n",
+ " W = T(V)\n",
+ " \n",
+ " return W\n",
+ " \n",
+ "e1 = np.array([[1], [0]])\n",
+ "e2 = np.array([[0], [1]])\n",
+ "\n",
+ "transformation_result_hscaling = transform_vectors(T_hscaling, e1, e2)\n",
+ "\n",
+ "print(\"Original vectors:\\n e1= \\n\", e1, \"\\n e2=\\n\", e2, \n",
+ " \"\\n\\n Result of the transformation (matrix form):\\n\", transformation_result_hscaling)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can get a visual understanding of the transformation, producing a plot which displays input vectors, and their transformations. Do not worry if the code in the following cell will not be clear - at this stage this is not important code to understand."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "def plot_transformation(T, e1, e2):\n",
+ " color_original = \"#129cab\"\n",
+ " color_transformed = \"#cc8933\"\n",
+ " \n",
+ " _, ax = plt.subplots(figsize=(7, 7))\n",
+ " ax.tick_params(axis='x', labelsize=14)\n",
+ " ax.tick_params(axis='y', labelsize=14)\n",
+ " ax.set_xticks(np.arange(-5, 5))\n",
+ " ax.set_yticks(np.arange(-5, 5))\n",
+ " \n",
+ " plt.axis([-5, 5, -5, 5])\n",
+ " plt.quiver([0, 0],[0, 0], [e1[0], e2[0]], [e1[1], e2[1]], color=color_original, angles='xy', scale_units='xy', scale=1)\n",
+ " plt.plot([0, e2[0], e1[0], e1[0]], \n",
+ " [0, e2[1], e2[1], e1[1]], \n",
+ " color=color_original)\n",
+ " e1_sgn = 0.4 * np.array([[1] if i==0 else [i] for i in np.sign(e1)])\n",
+ " ax.text(e1[0]-0.2+e1_sgn[0], e1[1]-0.2+e1_sgn[1], f'$e_1$', fontsize=14, color=color_original)\n",
+ " e2_sgn = 0.4 * np.array([[1] if i==0 else [i] for i in np.sign(e2)])\n",
+ " ax.text(e2[0]-0.2+e2_sgn[0], e2[1]-0.2+e2_sgn[1], f'$e_2$', fontsize=14, color=color_original)\n",
+ " \n",
+ " e1_transformed = T(e1)\n",
+ " e2_transformed = T(e2)\n",
+ " \n",
+ " plt.quiver([0, 0],[0, 0], [e1_transformed[0], e2_transformed[0]], [e1_transformed[1], e2_transformed[1]], \n",
+ " color=color_transformed, angles='xy', scale_units='xy', scale=1)\n",
+ " plt.plot([0,e2_transformed[0], e1_transformed[0]+e2_transformed[0], e1_transformed[0]], \n",
+ " [0,e2_transformed[1], e1_transformed[1]+e2_transformed[1], e1_transformed[1]], \n",
+ " color=color_transformed)\n",
+ " e1_transformed_sgn = 0.4 * np.array([[1] if i==0 else [i] for i in np.sign(e1_transformed)])\n",
+ " ax.text(e1_transformed[0][0]-0.2+e1_transformed_sgn[0], e1_transformed[1][0]-e1_transformed_sgn[1][0], \n",
+ " f'$T(e_1)$', fontsize=14, color=color_transformed)\n",
+ " e2_transformed_sgn = 0.4 * np.array([[1] if i==0 else [i] for i in np.sign(e2_transformed)])\n",
+ " ax.text(e2_transformed[0][0]-0.2+e2_transformed_sgn[0][0], e2_transformed[1][0]-e2_transformed_sgn[1][0], \n",
+ " f'$T(e_2)$', fontsize=14, color=color_transformed)\n",
+ " \n",
+ " plt.gca().set_aspect(\"equal\")\n",
+ " plt.show()\n",
+ " \n",
+ "plot_transformation(T_hscaling, e1, e2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can observe that the polygon has been stretched in the horizontal direction as a result of the transformation."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 4.2 - Example 2: Reflection about y-axis (the vertical axis)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Function `T_reflection_yaxis()` defined below corresponds to the reflection about y-axis:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original vectors:\n",
+ " e1= \n",
+ " [[1]\n",
+ " [0]] \n",
+ " e2=\n",
+ " [[0]\n",
+ " [1]] \n",
+ "\n",
+ " Result of the transformation (matrix form):\n",
+ " [[-1 0]\n",
+ " [ 0 1]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def T_reflection_yaxis(v):\n",
+ " A = np.array([[-1,0], [0,1]])\n",
+ " w = A @ v\n",
+ " \n",
+ " return w\n",
+ " \n",
+ "e1 = np.array([[1], [0]])\n",
+ "e2 = np.array([[0], [1]])\n",
+ "\n",
+ "transformation_result_reflection_yaxis = transform_vectors(T_reflection_yaxis, e1, e2)\n",
+ "\n",
+ "print(\"Original vectors:\\n e1= \\n\", e1,\"\\n e2=\\n\", e2, \n",
+ " \"\\n\\n Result of the transformation (matrix form):\\n\", transformation_result_reflection_yaxis)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can visualize this transformation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_transformation(T_reflection_yaxis, e1, e2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are many more standard linear transformations to explore. But now you have the required tools to apply them and visualize the results."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 5 - Application of Linear Transformations: Computer Graphics"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "A large number of basic geometric shapes is used in computer graphics. Such shapes (e.g. triangles, quadrilaterals) are defined by their vertexes (corners). Linear transformations are often used to generate complex shapes from the basic ones, through scaling, reflection, rotation, shearing etc. It provides opportunity to manipulate those shapes efficiently. \n",
+ "\n",
+ "The software responsible for rendering of graphics, has to process the coordinates of millions of vertexes. The use of matrix multiplication to manipulate coordinates helps to merge multiple transformations together, just applying matrix multiplication one by one in a sequence. And another advantage is that the dedicated hardware, such as Graphics Processing Units (GPUs), is designed specifically to handle these calculations in large numbers with high speed.\n",
+ "\n",
+ "So, matrix multiplication and linear transformations give you a super power, especially on scale!\n",
+ "\n",
+ "Here is an example where linear transformations could have helped to reduce the amount of work preparing the image:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "All of the subleafs are similar and can be prepared as just linear transformations of one original leaf.\n",
+ "\n",
+ "Let's see a simple example of two transformations applied to a leaf image. For the image transformations you can use an `OpenCV` library. First, upload and show the image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "img = cv2.imread('images/leaf_original.png', 0)\n",
+ "plt.imshow(img)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Of course, this is just a very simple leaf image (not a real example in preparation of the proper art work), but it will help you to get the idea how a few transformations can be applied in a row. Try to rotate the image 90 degrees clockwise and then apply a shear transformation, which can be visualized as:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Rotate the image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image_rotated = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)\n",
+ "\n",
+ "plt.imshow(image_rotated)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Applying the shear you will get the following output:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "rows,cols = image_rotated.shape\n",
+ "# 3 by 3 matrix as it is required for the OpenCV library, don't worry about the details of it for now.\n",
+ "M = np.float32([[1, 0.5, 0], [0, 1, 0], [0, 0, 1]])\n",
+ "image_rotated_sheared = cv2.warpPerspective(image_rotated, M, (int(cols), int(rows)))\n",
+ "plt.imshow(image_rotated_sheared)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "What if you will apply those two transformations in the opposite order? Do you think the result will be the same? Run the following code to check that:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image_sheared = cv2.warpPerspective(img, M, (int(cols), int(rows)))\n",
+ "image_sheared_rotated = cv2.rotate(image_sheared, cv2.ROTATE_90_CLOCKWISE)\n",
+ "plt.imshow(image_sheared_rotated)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Comparing last two images, you can clearly see that the outputs are different. This is because linear transformation can be defined as a matrix multiplication. Then, applying two transformations in a row, e.g. with matrices $A$ and $B$, you perform multiplications $B(Av)=(BA)v$, where $v$ is a vector. And remember, that generally you cannot change the order in the matrix multiplication (most of the time $BA\\neq AB$). Let's check that! Define two matrices, corresponding to the rotation and shear transformations:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "90 degrees clockwise rotation matrix:\n",
+ " [[ 0 1]\n",
+ " [-1 0]]\n",
+ "Matrix for the shear along x-axis:\n",
+ " [[1. 0.5]\n",
+ " [0. 1. ]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "M_rotation_90_clockwise = np.array([[0, 1], [-1, 0]])\n",
+ "M_shear_x = np.array([[1, 0.5], [0, 1]])\n",
+ "\n",
+ "print(\"90 degrees clockwise rotation matrix:\\n\", M_rotation_90_clockwise)\n",
+ "print(\"Matrix for the shear along x-axis:\\n\", M_shear_x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now check that the results of their multiplications `M_rotation_90_clockwise @ M_shear_x` and `M_shear_x @ M_rotation_90_clockwise` are different:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "M_rotation_90_clockwise by M_shear_x:\n",
+ " [[ 0. 1. ]\n",
+ " [-1. -0.5]]\n",
+ "M_shear_x by M_rotation_90_clockwise:\n",
+ " [[-0.5 1. ]\n",
+ " [-1. 0. ]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"M_rotation_90_clockwise by M_shear_x:\\n\", M_rotation_90_clockwise @ M_shear_x)\n",
+ "print(\"M_shear_x by M_rotation_90_clockwise:\\n\", M_shear_x @ M_rotation_90_clockwise)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This simple example shows that you need to be aware of the mathematical objects and their properties in the applications.\n",
+ "\n",
+ "Congratulations on completing this lab!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "collapsed_sections": [],
+ "name": "C1_W1_Assignment_Solution.ipynb",
+ "provenance": []
+ },
+ "coursera": {
+ "schema_names": [
+ "AI4MC1-1"
+ ]
+ },
+ "grader_version": "1",
+ "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.8.8"
+ },
+ "toc": {
+ "base_numbering": 1,
+ "nav_menu": {},
+ "number_sections": true,
+ "sideBar": true,
+ "skip_h1_title": false,
+ "title_cell": "Table of Contents",
+ "title_sidebar": "Contents",
+ "toc_cell": false,
+ "toc_position": {},
+ "toc_section_display": true,
+ "toc_window_display": false
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "478841ab876a4250505273c8a697bbc1b6b194054b009c227dc606f17fb56272"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/C1W3_Vector_operations.ipynb b/C1W3_Vector_operations.ipynb
new file mode 100644
index 0000000..f8dbc97
--- /dev/null
+++ b/C1W3_Vector_operations.ipynb
@@ -0,0 +1,778 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "reverse-interview",
+ "metadata": {},
+ "source": [
+ "# Vector Operations: Scalar Multiplication, Sum and Dot Product of Vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "parental-conclusion",
+ "metadata": {},
+ "source": [
+ "In this lab you will use Python and `NumPy` functions to perform main vector operations: scalar multiplication, sum of vectors and their dot product. You will also investigate the speed of calculations using loop and vectorized forms of these main linear algebra operations"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "looking-barcelona",
+ "metadata": {},
+ "source": [
+ "# Table of Contents\n",
+ "- [ 1 - Scalar Multiplication and Sum of Vectors](#1)\n",
+ " - [ 1.1 - Visualization of a Vector $v\\in\\mathbb{R}^2$](#1.1)\n",
+ " - [ 1.2 - Scalar Multiplication](#1.2)\n",
+ " - [ 1.3 - Sum of Vectors](#1.3)\n",
+ " - [ 1.4 - Norm of a Vector](#1.4)\n",
+ "- [ 2 - Dot Product](#2)\n",
+ " - [ 2.1 - Algebraic Definition of the Dot Product](#2.1)\n",
+ " - [ 2.2 - Dot Product using Python](#2.2)\n",
+ " - [ 2.3 - Speed of Calculations in Vectorized Form](#2.3)\n",
+ " - [ 2.4 - Geometric Definition of the Dot Product](#2.4)\n",
+ " - [ 2.5 - Application of the Dot Product: Vector Similarity](#2.5)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "advance-butler",
+ "metadata": {},
+ "source": [
+ "## Packages\n",
+ "\n",
+ "Load the `NumPy` package to access its functions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "promotional-buffer",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "desperate-library",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "severe-studio",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1 - Scalar Multiplication and Sum of Vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ethical-success",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 1.1 - Visualization of a Vector $v\\in\\mathbb{R}^2$\n",
+ "\n",
+ "You already have seen in the videos and labs, that vectors can be visualized as arrows, and it is easy to do it for a $v\\in\\mathbb{R}^2$, e.g.\n",
+ "$v=\\begin{bmatrix}\n",
+ " 1 & 3\n",
+ "\\end{bmatrix}^T$\n",
+ "\n",
+ "The following code will show the visualization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "korean-landing",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "def plot_vectors(list_v, list_label, list_color):\n",
+ " _, ax = plt.subplots(figsize=(10, 10))\n",
+ " ax.tick_params(axis='x', labelsize=14)\n",
+ " ax.tick_params(axis='y', labelsize=14)\n",
+ " ax.set_xticks(np.arange(-10, 10))\n",
+ " ax.set_yticks(np.arange(-10, 10))\n",
+ " \n",
+ " \n",
+ " plt.axis([-10, 10, -10, 10])\n",
+ " for i, v in enumerate(list_v):\n",
+ " sgn = 0.4 * np.array([[1] if i==0 else [i] for i in np.sign(v)])\n",
+ " plt.quiver(v[0], v[1], color=list_color[i], angles='xy', scale_units='xy', scale=1)\n",
+ " ax.text(v[0]-0.2+sgn[0], v[1]-0.2+sgn[1], list_label[i], fontsize=14, color=list_color[i])\n",
+ "\n",
+ " plt.grid()\n",
+ " plt.gca().set_aspect(\"equal\")\n",
+ " plt.show()\n",
+ "\n",
+ "v = np.array([[1],[3]])\n",
+ "# Arguments: list of vectors as NumPy arrays, labels, colors.\n",
+ "plot_vectors([v], [f\"$v$\"], [\"black\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "latin-immunology",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "original-translator",
+ "metadata": {},
+ "source": [
+ "The vector is defined by its **norm (length, magnitude)** and **direction**, not its actual position. But for clarity and convenience vectors are often plotted starting in the origin (in $\\mathbb{R}^2$ it is a point $(0,0)$) ."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "speaking-surgeon",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 1.2 - Scalar Multiplication\n",
+ "\n",
+ "**Scalar multiplication** of a vector $v=\\begin{bmatrix}\n",
+ " v_1 & v_2 & \\ldots & v_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$ by a scalar $k$ is a vector $kv=\\begin{bmatrix}\n",
+ " kv_1 & kv_2 & \\ldots & kv_n \n",
+ "\\end{bmatrix}^T$ (element by element multiplication). If $k>0$, then $kv$ is a vector pointing in the same direction as $v$ and it is $k$ times as long as $v$. If $k=0$, then $kv$ is a zero vector. If $k<0$, vector $kv$ will be pointing in the opposite direction. In Python you can perform this operation with a `*` operator. Check out the example below:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "acute-investment",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_vectors([v, 2*v, -2*v], [f\"$v$\", f\"$2v$\", f\"$-2v$\"], [\"black\", \"green\", \"blue\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "recent-processor",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "civil-county",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 1.3 - Sum of Vectors\n",
+ "\n",
+ "**Sum of vectors (vector addition)** can be performed by adding the corresponding components of the vectors: if $v=\\begin{bmatrix}\n",
+ " v_1 & v_2 & \\ldots & v_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$ and \n",
+ "$w=\\begin{bmatrix}\n",
+ " w_1 & w_2 & \\ldots & w_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$, then $v + w=\\begin{bmatrix}\n",
+ " v_1 + w_1 & v_2 + w_2 & \\ldots & v_n + w_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$. The so-called **parallelogram law** gives the rule for vector addition. For two vectors $u$ and $v$ represented by the adjacent sides (both in magnitude and direction) of a parallelogram drawn from a point, the vector sum $u+v$ is is represented by the diagonal of the parallelogram drawn from the same point:\n",
+ "\n",
+ "\n",
+ "\n",
+ "In Python you can either use `+` operator or `NumPy` function `np.add()`. In the following code you can uncomment the line to check that the result will be the same:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "acoustic-heath",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "v = np.array([[1],[3]])\n",
+ "w = np.array([[4],[-1]])\n",
+ "\n",
+ "plot_vectors([v, w, v + w], [f\"$v$\", f\"$w$\", f\"$v + w$\"], [\"black\", \"black\", \"red\"])\n",
+ "# plot_vectors([v, w, np.add(v, w)], [f\"$v$\", f\"$w$\", f\"$v + w$\"], [\"black\", \"black\", \"red\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "looking-tuning",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "nearby-portal",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 1.4 - Norm of a Vector\n",
+ "\n",
+ "The norm of a vector $v$ is denoted as $\\lvert v\\rvert$. It is a nonnegative number that describes the extent of the vector in space (its length). The norm of a vector can be found using `NumPy` function `np.linalg.norm()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "spare-timing",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Norm of a vector v is 3.1622776601683795\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Norm of a vector v is\", np.linalg.norm(v))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "silver-return",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "talented-survey",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2 - Dot Product"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "sunset-transmission",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.1 - Algebraic Definition of the Dot Product\n",
+ "\n",
+ "The **dot product** (or **scalar product**) is an algebraic operation that takes two vectors $x=\\begin{bmatrix}\n",
+ " x_1 & x_2 & \\ldots & x_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$ and \n",
+ "$y=\\begin{bmatrix}\n",
+ " y_1 & y_2 & \\ldots & y_n \n",
+ "\\end{bmatrix}^T\\in\\mathbb{R}^n$ and returns a single scalar. The dot product can be represented with a dot operator $x\\cdot y$ and defined as:\n",
+ "\n",
+ "$$x\\cdot y = \\sum_{i=1}^{n} x_iy_i = x_1y_1+x_2y_2+\\ldots+x_ny_n \\tag{1}$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "meaningful-timer",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.2 - Dot Product using Python\n",
+ "\n",
+ "The simplest way to calculate dot product in Python is to take the sum of element by element multiplications. You can define the vectors $x$ and $y$ by listing their coordinates:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "musical-battlefield",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = [1, -2, -5]\n",
+ "y = [4, 3, -1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "direct-asset",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "plastic-temple",
+ "metadata": {},
+ "source": [
+ "Next, let’s define a function `dot(x,y)` for the dot product calculation:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "signed-syndicate",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def dot(x, y):\n",
+ " s=0\n",
+ " for xi, yi in zip(x, y):\n",
+ " s += xi * yi\n",
+ " return s"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "advanced-brother",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "upper-highlight",
+ "metadata": {},
+ "source": [
+ "For the sake of simplicity, let’s assume that the vectors passed to the above function are always of the same size, so that you don’t need to perform additional checks.\n",
+ "\n",
+ "Now everything is ready to perform the dot product calculation calling the function `dot(x,y)`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "amazing-broadway",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The dot product of x and y is 3\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"The dot product of x and y is\", dot(x, y))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "technological-canyon",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "banned-dallas",
+ "metadata": {},
+ "source": [
+ "Dot product is very a commonly used operator, so `NumPy` linear algebra package provides quick way to calculate it using function `np.dot()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "accessible-kinase",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "np.dot(x,y) function returns dot product of x and y: 3\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"np.dot(x,y) function returns dot product of x and y:\", np.dot(x, y)) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "decent-syria",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "friendly-beast",
+ "metadata": {},
+ "source": [
+ "Note that you did not have to define vectors $x$ and $y$ as `NumPy` arrays, the function worked even with the lists. But there are alternative functions in Python, such as explicit operator `@` for the dot product, which can be applied only to the `NumPy` arrays. You can run the following cell to check that."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "built-paper",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "This line output is a dot product of x and y: 3\n",
+ "\n",
+ "This line output is an error:\n",
+ "unsupported operand type(s) for @: 'list' and 'list'\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"This line output is a dot product of x and y: \", np.array(x) @ np.array(y))\n",
+ "\n",
+ "print(\"\\nThis line output is an error:\")\n",
+ "try:\n",
+ " print(x @ y)\n",
+ "except TypeError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "received-hungary",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "central-museum",
+ "metadata": {},
+ "source": [
+ "As both `np.dot()` and `@` operators are commonly used, it is recommended to define vectors as `NumPy` arrays to avoid errors. Let's redefine vectors $x$ and $y$ as `NumPy` arrays to be safe:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "israeli-jumping",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = np.array(x)\n",
+ "y = np.array(y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cosmetic-husband",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "wicked-queensland",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.3 - Speed of Calculations in Vectorized Form\n",
+ "\n",
+ "Dot product operations in Machine Learning applications are applied to the large vectors with hundreds or thousands of coordinates (called **high dimensional vectors**). Training models based on large datasets often takes hours and days even on powerful machines. Speed of calculations is crucial for the training and deployment of your models. \n",
+ "\n",
+ "It is important to understand the difference in the speed of calculations using vectorized and the loop forms of the vectors and functions. In the loop form operations are performed one by one, while in the vectorized form they can be performed in parallel. In the section above you defined loop version of the dot product calculation (function `dot()`), while `np.dot()` and `@` are the functions representing vectorized form.\n",
+ "\n",
+ "Let's perform a simple experiment to compare their speed. Define new vectors $a$ and $b$ of the same size $1,000,000$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "amino-creation",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a = np.random.rand(1000000)\n",
+ "b = np.random.rand(1000000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "naughty-fellow",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "facial-refrigerator",
+ "metadata": {},
+ "source": [
+ "Use `time.time()` function to evaluate amount of time (in seconds) required to calculate dot product using the function `dot(x,y)` which you defined above: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "handed-influence",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dot product: 249918.19227243582\n",
+ "Time for the loop version:403.57518196105957 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "import time\n",
+ "\n",
+ "tic = time.time()\n",
+ "c = dot(a,b)\n",
+ "toc = time.time()\n",
+ "print(\"Dot product: \", c)\n",
+ "print (\"Time for the loop version:\" + str(1000*(toc-tic)) + \" ms\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "classified-maintenance",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "circular-radar",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "accessible-sherman",
+ "metadata": {},
+ "source": [
+ "Now compare it with the speed of the vectorized versions:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "determined-cooking",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dot product: 249918.19227243582\n",
+ "Time for the vectorized version, np.dot() function: 1.7201900482177734 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "tic = time.time()\n",
+ "c = np.dot(a,b)\n",
+ "toc = time.time()\n",
+ "print(\"Dot product: \", c)\n",
+ "print (\"Time for the vectorized version, np.dot() function: \" + str(1000*(toc-tic)) + \" ms\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "brazilian-ballet",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "scientific-empty",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dot product: 249918.19227243582\n",
+ "Time for the vectorized version, @ function: 1.821756362915039 ms\n"
+ ]
+ }
+ ],
+ "source": [
+ "tic = time.time()\n",
+ "c = a @ b\n",
+ "toc = time.time()\n",
+ "print(\"Dot product: \", c)\n",
+ "print (\"Time for the vectorized version, @ function: \" + str(1000*(toc-tic)) + \" ms\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "annoying-yield",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "useful-sleeping",
+ "metadata": {},
+ "source": [
+ "You can see that vectorization is extremely beneficial in terms of the speed of calculations!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "postal-latin",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.4 - Geometric Definition of the Dot Product\n",
+ "\n",
+ "In [Euclidean space](https://en.wikipedia.org/wiki/Euclidean_space), a Euclidean vector has both magnitude and direction. The dot product of two vectors $x$ and $y$ is defined by:\n",
+ "\n",
+ "$$x\\cdot y = \\lvert x\\rvert \\lvert y\\rvert \\cos(\\theta),\\tag{2}$$\n",
+ "\n",
+ "where $\\theta$ is the angle between the two vectors:\n",
+ "\n",
+ "\n",
+ "\n",
+ "This provides an easy way to test the orthogonality between vectors. If $x$ and $y$ are orthogonal (the angle between vectors is $90^{\\circ}$), then since $\\cos(90^{\\circ})=0$, it implies that **the dot product of any two orthogonal vectors must be $0$**. Let's test it, taking two vectors $i$ and $j$ we know are orthogonal:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "shared-climb",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The dot product of i and j is 0\n"
+ ]
+ }
+ ],
+ "source": [
+ "i = np.array([1, 0, 0])\n",
+ "j = np.array([0, 1, 0])\n",
+ "print(\"The dot product of i and j is\", dot(i, j))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "exciting-chair",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "thermal-railway",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.5 - Application of the Dot Product: Vector Similarity\n",
+ "\n",
+ "Geometric definition of a dot product is used in one of the applications - to evaluate **vector similarity**. In Natural Language Processing (NLP) words or phrases from vocabulary are mapped to a corresponding vector of real numbers. Similarity between two vectors can be defined as a cosine of the angle between them. When they point in the same direction, their similarity is 1 and it decreases with the increase of the angle. \n",
+ "\n",
+ "Then equation $(2)$ can be rearranged to evaluate cosine of the angle between vectors:\n",
+ "\n",
+ "$\\cos(\\theta)=\\frac{x \\cdot y}{\\lvert x\\rvert \\lvert y\\rvert}.\\tag{3}$\n",
+ "\n",
+ "Zero value corresponds to the zero similarity between vectors (and words corresponding to those vectors). Largest value is when vectors point in the same direction, lowest value is when vectors point in the opposite directions.\n",
+ "\n",
+ "This example of vector similarity is given to link the material with the Machine Learning applications. There will be no actual implementation of it in this Course. Some examples of implementation can be found in the Natual Language Processing Specialization.\n",
+ "\n",
+ "Well done, you have finished this lab!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "collect-needle",
+ "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.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/C1W3_matrix_multiplication.ipynb b/C1W3_matrix_multiplication.ipynb
new file mode 100644
index 0000000..c63afa7
--- /dev/null
+++ b/C1W3_matrix_multiplication.ipynb
@@ -0,0 +1,513 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "48446b1e",
+ "metadata": {},
+ "source": [
+ "# Matrix Multiplication"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4b6934ea",
+ "metadata": {},
+ "source": [
+ "In this lab you will use `NumPy` functions to perform matrix multiplication and see how it can be used in the Machine Learning applications. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4439a0e9",
+ "metadata": {},
+ "source": [
+ "# Table of Contents\n",
+ "\n",
+ "- [ 1 - Definition of Matrix Multiplication](#1)\n",
+ "- [ 2 - Matrix Multiplication using Python](#2)\n",
+ "- [ 3 - Matrix Convention and Broadcasting](#3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2743d75",
+ "metadata": {},
+ "source": [
+ "## Packages\n",
+ "\n",
+ "Load the `NumPy` package to access its functions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b463e5b7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "catholic-undergraduate",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5f9be5bb",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1 - Definition of Matrix Multiplication\n",
+ "\n",
+ "If $A$ is an $m \\times n$ matrix and $B$ is an $n \\times p$ matrix, the matrix product $C = AB$ (denoted without multiplication signs or dots) is defined to be the $m \\times p$ matrix such that \n",
+ "$c_{ij}=a_{i1}b_{1j}+a_{i2}b_{2j}+\\ldots+a_{in}b_{nj}=\\sum_{k=1}^{n} a_{ik}b_{kj}, \\tag{4}$\n",
+ "\n",
+ "where $a_{ik}$ are the elements of matrix $A$, $b_{kj}$ are the elements of matrix $B$, and $i = 1, \\ldots, m$, $k=1, \\ldots, n$, $j = 1, \\ldots, p$. In other words, $c_{ij}$ is the dot product of the $i$-th row of $A$ and the $j$-th column of $B$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ecd63af9",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2 - Matrix Multiplication using Python\n",
+ "\n",
+ "Like with the dot product, there are a few ways to perform matrix multiplication in Python. As discussed in the previous lab, the calculations are more efficient in the vectorized form. Let's discuss the most commonly used functions in the vectorized form. First, define two matrices:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "8b0f59f5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Matrix A (3 by 3):\n",
+ " [[4 9 9]\n",
+ " [9 1 6]\n",
+ " [9 2 3]]\n",
+ "Matrix B (3 by 2):\n",
+ " [[2 2]\n",
+ " [5 7]\n",
+ " [4 4]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "A = np.array([[4, 9, 9], [9, 1, 6], [9, 2, 3]])\n",
+ "print(\"Matrix A (3 by 3):\\n\", A)\n",
+ "\n",
+ "B = np.array([[2, 2], [5, 7], [4, 4]])\n",
+ "print(\"Matrix B (3 by 2):\\n\", B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cross-sampling",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdf047c9",
+ "metadata": {},
+ "source": [
+ "You can multiply matrices $A$ and $B$ using `NumPy` package function `np.matmul()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "43452598",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.matmul(A, B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "otherwise-anderson",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7be5d42a",
+ "metadata": {},
+ "source": [
+ "Which will output $3 \\times 2$ matrix as a `np.array`. Python operator `@` will also work here giving the same result:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "bb36ba42",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A @ B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "secret-reform",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0186638b",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3 - Matrix Convention and Broadcasting\n",
+ "\n",
+ "Mathematically, matrix multiplication is defined only if number of the columns of matrix $A$ is equal to the number of the rows of matrix $B$ (you can check again the definition in the secition [1](#1) and see that otherwise the dot products between rows and columns will not be defined). \n",
+ "\n",
+ "Thus, in the example above ([2](#2)), changing the order of matrices when performing the multiplication $BA$ will not work as the above rule does not hold anymore. You can check it by running the cells below - both of them will give errors."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "3ecc05e5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " np.matmul(B, A)\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "prerequisite-production",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ea9c6d13",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " B @ A\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "descending-nutrition",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05d9a674",
+ "metadata": {},
+ "source": [
+ "So when using matrix multiplication you will need to be very careful about the dimensions - the number of the columns in the first matrix should match the number of the rows in the second matrix. This is very important for your future understanding of Neural Networks and how they work. \n",
+ "\n",
+ "However, for multiplying of the vectors, `NumPy` has a shortcut. You can define two vectors $x$ and $y$ of the same size (which one can understand as two $3 \\times 1$ matrices). If you check the shape of the vector $x$, you can see that :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "fab77ce6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Shape of vector x: (3,)\n",
+ "Number of dimensions of vector x: 1\n",
+ "Shape of vector x, reshaped to a matrix: (3, 1)\n",
+ "Number of dimensions of vector x, reshaped to a matrix: 2\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = np.array([1, -2, -5])\n",
+ "y = np.array([4, 3, -1])\n",
+ "\n",
+ "print(\"Shape of vector x:\", x.shape)\n",
+ "print(\"Number of dimensions of vector x:\", x.ndim)\n",
+ "print(\"Shape of vector x, reshaped to a matrix:\", x.reshape((3, 1)).shape)\n",
+ "print(\"Number of dimensions of vector x, reshaped to a matrix:\", x.reshape((3, 1)).ndim)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "official-timeline",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5bd337df",
+ "metadata": {},
+ "source": [
+ "Following the matrix convention, multiplication of matrices $3 \\times 1$ and $3 \\times 1$ is not defined. For matrix multiplication you would expect an error in the following cell, but let's check the output:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "f655677c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.matmul(x,y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "correct-carolina",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fc01d74",
+ "metadata": {},
+ "source": [
+ "You can see that there is no error and that the result is actually a dot product $x \\cdot y\\,$! So, vector $x$ was automatically transposed into the vector $1 \\times 3$ and matrix multiplication $x^Ty$ was calculated. While this is very convenient, you need to keep in mind such functionality in Python and pay attention to not use it in a wrong way. The following cell will return an error:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d92006f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " np.matmul(x.reshape((3, 1)), y.reshape((3, 1)))\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "immediate-anatomy",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ace12c7d",
+ "metadata": {},
+ "source": [
+ "You might have a question in you mind: does `np.dot()` function also work for matrix multiplication? Let's try it:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "f296e528",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.dot(A, B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "golden-infrared",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8dbbdc0f",
+ "metadata": {},
+ "source": [
+ "Yes, it works! What actually happens is what is called **broadcasting** in Python: `NumPy` broadcasts this dot product operation to all rows and all columns, you get the resultant product matrix. Broadcasting also works in other cases, for example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "68ded501",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 2, 7, 7],\n",
+ " [ 7, -1, 4],\n",
+ " [ 7, 0, 1]])"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A - 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "satisfied-floating",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eec1d0d2",
+ "metadata": {},
+ "source": [
+ "Mathematically, subtraction of the $3 \\times 3$ matrix $A$ and a scalar is not defined, but Python broadcasts the scalar, creating a $3 \\times 3$ `np.array` and performing subtraction element by element. A practical example of matrix multiplication can be seen in a linear regression model. You will implement it in this week's assignment!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86605d6f",
+ "metadata": {},
+ "source": [
+ "Congratulations on finishing this lab!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76db64ac",
+ "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.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Course_Materials-C1-W3.pdf b/Course_Materials-C1-W3.pdf
new file mode 100644
index 0000000..14829d3
Binary files /dev/null and b/Course_Materials-C1-W3.pdf differ
![](\"images/nn_model_linear_regression_multiple.png\")
\n",
+ "\n",
+ "The perceptron output calculation for a training example $x = \\begin{bmatrix} x_1& x_2\\end{bmatrix}$ can be written with dot product:\n",
+ "\n",
+ "$$z = w_1x_1 + w_2x_2+ b = Wx + b$$\n",
+ "\n",
+ "where weights are in the vector $W = \\begin{bmatrix} w_1 & w_2\\end{bmatrix}$ and bias $b$ is a scalar. The output layer will have the same single node $\\hat{y}= z$.\n",
+ "\n",
+ "Organise all training examples in a matrix $X$ of a shape ($2 \\times m$), putting $x_1$ and $x_2$ into columns. Then matrix multiplication of $W$ ($1 \\times 2$) and $X$ ($2 \\times m$) will give a ($1 \\times m$) vector\n",
+ "\n",
+ "$$WX = \n",
+ "\\begin{bmatrix} w_1 & w_2\\end{bmatrix} \n",
+ "\\begin{bmatrix} \n",
+ "x_1^{(1)} & x_1^{(2)} & \\dots & x_1^{(m)} \\\\ \n",
+ "x_2^{(1)} & x_2^{(2)} & \\dots & x_2^{(m)} \\\\ \\end{bmatrix}\n",
+ "=\\begin{bmatrix} \n",
+ "w_1x_1^{(1)} + w_2x_2^{(1)} & \n",
+ "w_1x_1^{(2)} + w_2x_2^{(2)} & \\dots & \n",
+ "w_1x_1^{(m)} + w_2x_2^{(m)}\\end{bmatrix}.$$\n",
+ "\n",
+ "And the model can be written as\n",
+ "\n",
+ "\\begin{align}\n",
+ "Z &= W X + b,\\\\\n",
+ "\\hat{Y} &= Z,\n",
+ "\\tag{8}\\end{align}\n",
+ "\n",
+ "where $b$ is broadcasted to the vector of a size ($1 \\times m$). These are the calculations to perform in the forward propagation step.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, you can compare the resulting vector of the predictions $\\hat{Y}$ ($1 \\times m$) with the original vector of data $Y$. This can be done with the so called **cost function** that measures how close your vector of predictions is to the training data. It evaluates how well the parameters $w$ and $b$ work to solve the problem. There are many different cost functions available depending on the nature of your problem. For your simple neural network you can calculate it as:\n",
+ "\n",
+ "$$\\mathcal{L}\\left(w, b\\right) = \\frac{1}{2m}\\sum_{i=1}^{m} \\left(\\hat{y}^{(i)} - y^{(i)}\\right)^2.\\tag{5}$$\n",
+ "\n",
+ "The aim is to minimize the cost function during the training, which will minimize the differences between original values $y_i$ and predicted values $\\hat{y}_i$ (division by $2m$ is taken just for scaling purposes).\n",
+ "\n",
+ "When your weights were just initialized with some random values, and no training was done yet, you can't expect good results.\n",
+ "\n",
+ "The next step is to adjust the weights and bias, in order to minimize the cost function. This process is called **backward propagation** and is done iteratively: you update the parameters with a small change and repeat the process.\n",
+ "\n",
+ "*Note*: Backward propagation is not covered in this Course - it will be discussed in the next Course of this Specialization.\n",
+ "\n",
+ "The general **methodology** to build a neural network is to:\n",
+ "1. Define the neural network structure ( # of input units, # of hidden units, etc). \n",
+ "2. Initialize the model's parameters\n",
+ "3. Loop:\n",
+ " - Implement forward propagation (calculate the perceptron output),\n",
+ " - Implement backward propagation (to get the required corrections for the parameters),\n",
+ " - Update parameters.\n",
+ "4. Make predictions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.3 Parameters of the Neural Network\n",
+ "\n",
+ "The neural network you will be working with has $3$ parameters. Two weights and one bias, you will start initalizing these parameters as some random numbers, so the algorithm can start at some point. The parameters will be stored in a dictionary."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'W': array([[ 0.0064941 , -0.01006149]]), 'b': array([[0.]])}\n"
+ ]
+ }
+ ],
+ "source": [
+ "parameters = utils.initialize_parameters(2)\n",
+ "print(parameters)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.4 Forward propagation\n",
+ "\n",
+ "\n",
+ "### Exercise 5\n",
+ "\n",
+ "Implement `forward_propagation()`.\n",
+ "\n",
+ "**Instructions**:\n",
+ "- Look at the mathematical representation of your model:\n",
+ "\\begin{align}\n",
+ "Z &= W X + b\\\\\n",
+ "\\hat{Y} &= Z,\n",
+ "\\end{align}\n",
+ "- The steps you have to implement are:\n",
+ " 1. Retrieve each parameter from the dictionary \"parameters\" by using `parameters[\"..\"]`.\n",
+ " 2. Implement Forward Propagation. Compute `Z` multiplying arrays `W`, `X` and adding vector `b`. Set the prediction array $A$ equal to $Z$. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# GRADED FUNCTION: forward_propagation\n",
+ "\n",
+ "def forward_propagation(X, parameters):\n",
+ " \"\"\"\n",
+ " Argument:\n",
+ " X -- input data of size (n_x, m), where n_x is the dimension input (in our example is 2) and m is the number of training samples\n",
+ " parameters -- python dictionary containing your parameters (output of initialization function)\n",
+ " \n",
+ " Returns:\n",
+ " Y_hat -- The output of size (1, m)\n",
+ " \"\"\"\n",
+ " # Retrieve each parameter from the dictionary \"parameters\".\n",
+ " W = parameters[\"W\"]\n",
+ " b = parameters[\"b\"]\n",
+ " \n",
+ " # Implement Forward Propagation to calculate Z.\n",
+ " ### START CODE HERE ### (~ 2 lines of code)\n",
+ " Z = W@X + b\n",
+ " Y_hat = Z\n",
+ " ### END CODE HERE ###\n",
+ " \n",
+ "\n",
+ " return Y_hat"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[92m All tests passed\n"
+ ]
+ }
+ ],
+ "source": [
+ "w3_unittest.test_forward_propagation(forward_propagation)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.5 Defining the cost function\n",
+ "\n",
+ "The cost function used to traing this model is \n",
+ "\n",
+ "$$\\mathcal{L}\\left(w, b\\right) = \\frac{1}{2m}\\sum_{i=1}^{m} \\left(\\hat{y}^{(i)} - y^{(i)}\\right)^2$$\n",
+ "\n",
+ "The next implementation is not graded."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "def compute_cost(Y_hat, Y):\n",
+ " \"\"\"\n",
+ " Computes the cost function as a sum of squares\n",
+ " \n",
+ " Arguments:\n",
+ " Y_hat -- The output of the neural network of shape (n_y, number of examples)\n",
+ " Y -- \"true\" labels vector of shape (n_y, number of examples)\n",
+ " \n",
+ " Returns:\n",
+ " cost -- sum of squares scaled by 1/(2*number of examples)\n",
+ " \n",
+ " \"\"\"\n",
+ " # Number of examples.\n",
+ " m = Y.shape[1]\n",
+ "\n",
+ " # Compute the cost function.\n",
+ " cost = np.sum((Y_hat - Y)**2)/(2*m)\n",
+ " \n",
+ " return cost"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### Exercise 6\n",
+ "\n",
+ "Now you're ready to implement your neural network. The next function will implement the training process and it will return the updated parameters dictionary where you will be able to make predictions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "tags": [
+ "graded"
+ ]
+ },
+ "outputs": [],
+ "source": [
+ "# GRADED FUNCTION: nn_model\n",
+ "\n",
+ "def nn_model(X, Y, num_iterations=1000, print_cost=False):\n",
+ " \"\"\"\n",
+ " Arguments:\n",
+ " X -- dataset of shape (n_x, number of examples)\n",
+ " Y -- labels of shape (1, number of examples)\n",
+ " num_iterations -- number of iterations in the loop\n",
+ " print_cost -- if True, print the cost every iteration\n",
+ " \n",
+ " Returns:\n",
+ " parameters -- parameters learnt by the model. They can then be used to make predictions.\n",
+ " \"\"\"\n",
+ " \n",
+ " n_x = X.shape[0]\n",
+ " \n",
+ " # Initialize parameters\n",
+ " parameters = utils.initialize_parameters(n_x) \n",
+ " \n",
+ " # Loop\n",
+ " for i in range(0, num_iterations):\n",
+ " \n",
+ " ### START CODE HERE ### (~ 2 lines of code)\n",
+ " # Forward propagation. Inputs: \"X, parameters, n_y\". Outputs: \"Y_hat\".\n",
+ " Y_hat = forward_propagation(X, parameters)\n",
+ " \n",
+ " # Cost function. Inputs: \"Y_hat, Y\". Outputs: \"cost\".\n",
+ " cost = compute_cost(Y_hat, Y)\n",
+ " ### END CODE HERE ###\n",
+ " \n",
+ " \n",
+ " # Parameters update.\n",
+ " parameters = utils.train_nn(parameters, Y_hat, X, Y, learning_rate = 0.001) \n",
+ " \n",
+ " # Print the cost every iteration.\n",
+ " if print_cost:\n",
+ " if i%100 == 0:\n",
+ " print (\"Cost after iteration %i: %f\" %(i, cost))\n",
+ "\n",
+ " return parameters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[92m All tests passed\n"
+ ]
+ }
+ ],
+ "source": [
+ "w3_unittest.test_nn_model(nn_model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 3.6 - Training the neural network\n",
+ "\n",
+ "Now let's load a dataset to train the neural network."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "df = pd.read_csv(\"data/toy_dataset.csv\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "![](\"images/barnsley_fern.png\")
\n",
+ "\n",
+ "\n",
+ "All of the subleafs are similar and can be prepared as just linear transformations of one original leaf.\n",
+ "\n",
+ "Let's see a simple example of two transformations applied to a leaf image. For the image transformations you can use an `OpenCV` library. First, upload and show the image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "![](\"images/shear_transformation.png\")
\n",
+ "\n",
+ "Rotate the image:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "![](\"images/sum_of_vectors.png\")
\n",
+ "\n",
+ "In Python you can either use `+` operator or `NumPy` function `np.add()`. In the following code you can uncomment the line to check that the result will be the same:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "acoustic-heath",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "![](\"images/dot_product_geometric.png\")
\n",
+ "\n",
+ "This provides an easy way to test the orthogonality between vectors. If $x$ and $y$ are orthogonal (the angle between vectors is $90^{\\circ}$), then since $\\cos(90^{\\circ})=0$, it implies that **the dot product of any two orthogonal vectors must be $0$**. Let's test it, taking two vectors $i$ and $j$ we know are orthogonal:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "shared-climb",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The dot product of i and j is 0\n"
+ ]
+ }
+ ],
+ "source": [
+ "i = np.array([1, 0, 0])\n",
+ "j = np.array([0, 1, 0])\n",
+ "print(\"The dot product of i and j is\", dot(i, j))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "exciting-chair",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "thermal-railway",
+ "metadata": {},
+ "source": [
+ "\n",
+ "### 2.5 - Application of the Dot Product: Vector Similarity\n",
+ "\n",
+ "Geometric definition of a dot product is used in one of the applications - to evaluate **vector similarity**. In Natural Language Processing (NLP) words or phrases from vocabulary are mapped to a corresponding vector of real numbers. Similarity between two vectors can be defined as a cosine of the angle between them. When they point in the same direction, their similarity is 1 and it decreases with the increase of the angle. \n",
+ "\n",
+ "Then equation $(2)$ can be rearranged to evaluate cosine of the angle between vectors:\n",
+ "\n",
+ "$\\cos(\\theta)=\\frac{x \\cdot y}{\\lvert x\\rvert \\lvert y\\rvert}.\\tag{3}$\n",
+ "\n",
+ "Zero value corresponds to the zero similarity between vectors (and words corresponding to those vectors). Largest value is when vectors point in the same direction, lowest value is when vectors point in the opposite directions.\n",
+ "\n",
+ "This example of vector similarity is given to link the material with the Machine Learning applications. There will be no actual implementation of it in this Course. Some examples of implementation can be found in the Natual Language Processing Specialization.\n",
+ "\n",
+ "Well done, you have finished this lab!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "collect-needle",
+ "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.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/C1W3_matrix_multiplication.ipynb b/C1W3_matrix_multiplication.ipynb
new file mode 100644
index 0000000..c63afa7
--- /dev/null
+++ b/C1W3_matrix_multiplication.ipynb
@@ -0,0 +1,513 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "48446b1e",
+ "metadata": {},
+ "source": [
+ "# Matrix Multiplication"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4b6934ea",
+ "metadata": {},
+ "source": [
+ "In this lab you will use `NumPy` functions to perform matrix multiplication and see how it can be used in the Machine Learning applications. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4439a0e9",
+ "metadata": {},
+ "source": [
+ "# Table of Contents\n",
+ "\n",
+ "- [ 1 - Definition of Matrix Multiplication](#1)\n",
+ "- [ 2 - Matrix Multiplication using Python](#2)\n",
+ "- [ 3 - Matrix Convention and Broadcasting](#3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2743d75",
+ "metadata": {},
+ "source": [
+ "## Packages\n",
+ "\n",
+ "Load the `NumPy` package to access its functions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b463e5b7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "catholic-undergraduate",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5f9be5bb",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 1 - Definition of Matrix Multiplication\n",
+ "\n",
+ "If $A$ is an $m \\times n$ matrix and $B$ is an $n \\times p$ matrix, the matrix product $C = AB$ (denoted without multiplication signs or dots) is defined to be the $m \\times p$ matrix such that \n",
+ "$c_{ij}=a_{i1}b_{1j}+a_{i2}b_{2j}+\\ldots+a_{in}b_{nj}=\\sum_{k=1}^{n} a_{ik}b_{kj}, \\tag{4}$\n",
+ "\n",
+ "where $a_{ik}$ are the elements of matrix $A$, $b_{kj}$ are the elements of matrix $B$, and $i = 1, \\ldots, m$, $k=1, \\ldots, n$, $j = 1, \\ldots, p$. In other words, $c_{ij}$ is the dot product of the $i$-th row of $A$ and the $j$-th column of $B$."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ecd63af9",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 2 - Matrix Multiplication using Python\n",
+ "\n",
+ "Like with the dot product, there are a few ways to perform matrix multiplication in Python. As discussed in the previous lab, the calculations are more efficient in the vectorized form. Let's discuss the most commonly used functions in the vectorized form. First, define two matrices:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "8b0f59f5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Matrix A (3 by 3):\n",
+ " [[4 9 9]\n",
+ " [9 1 6]\n",
+ " [9 2 3]]\n",
+ "Matrix B (3 by 2):\n",
+ " [[2 2]\n",
+ " [5 7]\n",
+ " [4 4]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "A = np.array([[4, 9, 9], [9, 1, 6], [9, 2, 3]])\n",
+ "print(\"Matrix A (3 by 3):\\n\", A)\n",
+ "\n",
+ "B = np.array([[2, 2], [5, 7], [4, 4]])\n",
+ "print(\"Matrix B (3 by 2):\\n\", B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cross-sampling",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cdf047c9",
+ "metadata": {},
+ "source": [
+ "You can multiply matrices $A$ and $B$ using `NumPy` package function `np.matmul()`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "43452598",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.matmul(A, B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "otherwise-anderson",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7be5d42a",
+ "metadata": {},
+ "source": [
+ "Which will output $3 \\times 2$ matrix as a `np.array`. Python operator `@` will also work here giving the same result:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "bb36ba42",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A @ B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "secret-reform",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0186638b",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## 3 - Matrix Convention and Broadcasting\n",
+ "\n",
+ "Mathematically, matrix multiplication is defined only if number of the columns of matrix $A$ is equal to the number of the rows of matrix $B$ (you can check again the definition in the secition [1](#1) and see that otherwise the dot products between rows and columns will not be defined). \n",
+ "\n",
+ "Thus, in the example above ([2](#2)), changing the order of matrices when performing the multiplication $BA$ will not work as the above rule does not hold anymore. You can check it by running the cells below - both of them will give errors."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "3ecc05e5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " np.matmul(B, A)\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "prerequisite-production",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ea9c6d13",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " B @ A\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "descending-nutrition",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05d9a674",
+ "metadata": {},
+ "source": [
+ "So when using matrix multiplication you will need to be very careful about the dimensions - the number of the columns in the first matrix should match the number of the rows in the second matrix. This is very important for your future understanding of Neural Networks and how they work. \n",
+ "\n",
+ "However, for multiplying of the vectors, `NumPy` has a shortcut. You can define two vectors $x$ and $y$ of the same size (which one can understand as two $3 \\times 1$ matrices). If you check the shape of the vector $x$, you can see that :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "fab77ce6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Shape of vector x: (3,)\n",
+ "Number of dimensions of vector x: 1\n",
+ "Shape of vector x, reshaped to a matrix: (3, 1)\n",
+ "Number of dimensions of vector x, reshaped to a matrix: 2\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = np.array([1, -2, -5])\n",
+ "y = np.array([4, 3, -1])\n",
+ "\n",
+ "print(\"Shape of vector x:\", x.shape)\n",
+ "print(\"Number of dimensions of vector x:\", x.ndim)\n",
+ "print(\"Shape of vector x, reshaped to a matrix:\", x.reshape((3, 1)).shape)\n",
+ "print(\"Number of dimensions of vector x, reshaped to a matrix:\", x.reshape((3, 1)).ndim)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "official-timeline",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5bd337df",
+ "metadata": {},
+ "source": [
+ "Following the matrix convention, multiplication of matrices $3 \\times 1$ and $3 \\times 1$ is not defined. For matrix multiplication you would expect an error in the following cell, but let's check the output:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "f655677c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.matmul(x,y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "correct-carolina",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2fc01d74",
+ "metadata": {},
+ "source": [
+ "You can see that there is no error and that the result is actually a dot product $x \\cdot y\\,$! So, vector $x$ was automatically transposed into the vector $1 \\times 3$ and matrix multiplication $x^Ty$ was calculated. While this is very convenient, you need to keep in mind such functionality in Python and pay attention to not use it in a wrong way. The following cell will return an error:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d92006f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "try:\n",
+ " np.matmul(x.reshape((3, 1)), y.reshape((3, 1)))\n",
+ "except ValueError as err:\n",
+ " print(err)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "immediate-anatomy",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ace12c7d",
+ "metadata": {},
+ "source": [
+ "You might have a question in you mind: does `np.dot()` function also work for matrix multiplication? Let's try it:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "f296e528",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 89, 107],\n",
+ " [ 47, 49],\n",
+ " [ 40, 44]])"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.dot(A, B)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "golden-infrared",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8dbbdc0f",
+ "metadata": {},
+ "source": [
+ "Yes, it works! What actually happens is what is called **broadcasting** in Python: `NumPy` broadcasts this dot product operation to all rows and all columns, you get the resultant product matrix. Broadcasting also works in other cases, for example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "68ded501",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 2, 7, 7],\n",
+ " [ 7, -1, 4],\n",
+ " [ 7, 0, 1]])"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "A - 2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "satisfied-floating",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eec1d0d2",
+ "metadata": {},
+ "source": [
+ "Mathematically, subtraction of the $3 \\times 3$ matrix $A$ and a scalar is not defined, but Python broadcasts the scalar, creating a $3 \\times 3$ `np.array` and performing subtraction element by element. A practical example of matrix multiplication can be seen in a linear regression model. You will implement it in this week's assignment!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "86605d6f",
+ "metadata": {},
+ "source": [
+ "Congratulations on finishing this lab!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "76db64ac",
+ "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.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Course_Materials-C1-W3.pdf b/Course_Materials-C1-W3.pdf
new file mode 100644
index 0000000..14829d3
Binary files /dev/null and b/Course_Materials-C1-W3.pdf differ