ml-labs-01-intro-to-numpy.ipynb

{"cells":[{"source":"<a href=\"https://www.kaggle.com/code/sacrum/ml-labs-01-intro-to-numpy?scriptVersionId=178241452\" target=\"_blank\"><img align=\"left\" alt=\"Kaggle\" title=\"Open in Kaggle\" src=\"https://kaggle.com/static/images/open-in-kaggle.svg\"></a>","metadata":{},"cell_type":"markdown"},{"cell_type":"markdown","id":"b4d0d882","metadata":{"papermill":{"duration":0.009644,"end_time":"2024-05-17T16:20:02.023257","exception":false,"start_time":"2024-05-17T16:20:02.013613","status":"completed"},"tags":[]},"source":["## Intro to Numpy\n","\n","The notebook demonstrates NumPy's efficiency for mathematical operations like array reshaping, sigmoid, softmax, dot and outer products, L1 and L2 losses, and matrix operations. It highlights NumPy's superiority over standard Python lists in speed and convenience for scientific computing and machine learning tasks."]},{"cell_type":"markdown","id":"dd4aa6d6","metadata":{"id":"8VeDg747Pu7E","papermill":{"duration":0.00782,"end_time":"2024-05-17T16:20:02.039998","exception":false,"start_time":"2024-05-17T16:20:02.032178","status":"completed"},"tags":[]},"source":["### Reshape\n","Create a function that takes a NumPy array of shape (length,width,height) and converts it in to a vector of shape `(length*width*height,1)`. Use the function `array.reshape()` for this."]},{"cell_type":"code","execution_count":1,"id":"a10f6709","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.058508Z","iopub.status.busy":"2024-05-17T16:20:02.057792Z","iopub.status.idle":"2024-05-17T16:20:02.075106Z","shell.execute_reply":"2024-05-17T16:20:02.074264Z"},"id":"miOuUq_GPybj","outputId":"6264ef1f-5933-40eb-edbf-66639ce8a3fe","papermill":{"duration":0.030326,"end_time":"2024-05-17T16:20:02.078541","exception":false,"start_time":"2024-05-17T16:20:02.048215","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Original Array:\n","[[[0.19787665 0.7866535  0.17973722 0.46509214]\n","  [0.21763713 0.4306783  0.74081572 0.68779453]\n","  [0.03846504 0.10000278 0.62991432 0.04215485]]\n","\n"," [[0.65342107 0.58892378 0.9600664  0.03347859]\n","  [0.84814677 0.36894817 0.70118958 0.77329727]\n","  [0.81103335 0.91773337 0.69556171 0.09156923]]]\n","\n","Resulting Vector:\n","[[0.19787665]\n"," [0.7866535 ]\n"," [0.17973722]\n"," [0.46509214]\n"," [0.21763713]\n"," [0.4306783 ]\n"," [0.74081572]\n"," [0.68779453]\n"," [0.03846504]\n"," [0.10000278]\n"," [0.62991432]\n"," [0.04215485]\n"," [0.65342107]\n"," [0.58892378]\n"," [0.9600664 ]\n"," [0.03347859]\n"," [0.84814677]\n"," [0.36894817]\n"," [0.70118958]\n"," [0.77329727]\n"," [0.81103335]\n"," [0.91773337]\n"," [0.69556171]\n"," [0.09156923]]\n"]}],"source":["import numpy as np\n","\n","def convert_to_vector(array):\n","    vector = array.reshape((array.shape[0] * array.shape[1] * array.shape[2], 1))\n","    return vector\n","\n","sample_array = np.random.random((2, 3, 4))\n","\n","vector_result = convert_to_vector(sample_array)\n","\n","print(\"Original Array:\")\n","print(sample_array)\n","print(\"\\nResulting Vector:\")\n","print(vector_result)\n"]},{"cell_type":"markdown","id":"b9bfd50b","metadata":{"id":"eO8RARDMQTY-","papermill":{"duration":0.008122,"end_time":"2024-05-17T16:20:02.095684","exception":false,"start_time":"2024-05-17T16:20:02.087562","status":"completed"},"tags":[]},"source":["### Sigmoid\n","- Write a function that returns the sigmoid of a real number x. Use `math.exp(x)` for the exponential function. `Sigmoid(x)=1/(1+exp(-x))`.\n","- Now create a list of 5 values and call your sigmoid function with the list as input. You will get an error because `math.exp()` only works when input is a real number. It does not work with vectors and matrices. Now create a new function for sigmoid but this time use `np.exp()` instead of `math.exp()`. `np.exp()` works with all types of inputs including real numbers, vectors and matrices. In deep learning we mostly use matrices and vectors. This is why NumPy is more useful. Call your new function with a vector created by `np.array()` function."]},{"cell_type":"code","execution_count":2,"id":"c940cc3f","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.114404Z","iopub.status.busy":"2024-05-17T16:20:02.114016Z","iopub.status.idle":"2024-05-17T16:20:02.118896Z","shell.execute_reply":"2024-05-17T16:20:02.11788Z"},"id":"UrG4-fPvmZOO","papermill":{"duration":0.017021,"end_time":"2024-05-17T16:20:02.121143","exception":false,"start_time":"2024-05-17T16:20:02.104122","status":"completed"},"tags":[]},"outputs":[],"source":["import math\n","\n","def sigmoid_math_exp(x):\n","    return 1 / (1 + math.exp(-x))\n"]},{"cell_type":"code","execution_count":3,"id":"b2ad96f4","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.139962Z","iopub.status.busy":"2024-05-17T16:20:02.139584Z","iopub.status.idle":"2024-05-17T16:20:02.144606Z","shell.execute_reply":"2024-05-17T16:20:02.14347Z"},"id":"xjFYL4ldmZRG","papermill":{"duration":0.017259,"end_time":"2024-05-17T16:20:02.147024","exception":false,"start_time":"2024-05-17T16:20:02.129765","status":"completed"},"tags":[]},"outputs":[],"source":["import numpy as np\n","\n","def sigmoid_np_exp(x):\n","    return 1 / (1 + np.exp(-x))\n"]},{"cell_type":"code","execution_count":4,"id":"f2deefe1","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.166721Z","iopub.status.busy":"2024-05-17T16:20:02.16628Z","iopub.status.idle":"2024-05-17T16:20:02.173098Z","shell.execute_reply":"2024-05-17T16:20:02.172373Z"},"id":"6uUhoYjlQIYW","outputId":"3840d25c-8831-41a8-894c-7c13333850f9","papermill":{"duration":0.019267,"end_time":"2024-05-17T16:20:02.175856","exception":false,"start_time":"2024-05-17T16:20:02.156589","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Results using math.exp(): [0.7310585786300049, 0.8807970779778823, 0.9525741268224334, 0.9820137900379085, 0.9933071490757153]\n","Results using np.exp(): [0.73105858 0.88079708 0.95257413 0.98201379 0.99330715]\n"]}],"source":["values = [1.0, 2.0, 3.0, 4.0, 5.0]\n","try:\n","    sigmoid_result_math_exp = [sigmoid_math_exp(val) for val in values]\n","except TypeError as e:\n","    print(f\"Error: {e}\")\n","\n","vector_values = np.array(values)\n","sigmoid_result_np_exp = sigmoid_np_exp(vector_values)\n","\n","print(\"Results using math.exp():\", sigmoid_result_math_exp)\n","print(\"Results using np.exp():\", sigmoid_result_np_exp)"]},{"cell_type":"markdown","id":"241a9fec","metadata":{"id":"E8vOW5NOncaT","papermill":{"duration":0.008317,"end_time":"2024-05-17T16:20:02.192826","exception":false,"start_time":"2024-05-17T16:20:02.184509","status":"completed"},"tags":[]},"source":["### Softmax\n","Create a function that takes a matrix as input and returns the softmax (by row) of matrix.\n","Check if your function is working correctly by using suitable inputs."]},{"cell_type":"code","execution_count":5,"id":"ec210b6e","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.21219Z","iopub.status.busy":"2024-05-17T16:20:02.21152Z","iopub.status.idle":"2024-05-17T16:20:02.21664Z","shell.execute_reply":"2024-05-17T16:20:02.215809Z"},"id":"BFpk2-ownWTw","papermill":{"duration":0.017503,"end_time":"2024-05-17T16:20:02.218863","exception":false,"start_time":"2024-05-17T16:20:02.20136","status":"completed"},"tags":[]},"outputs":[],"source":["import numpy as np\n","\n","def softmax(matrix):\n","    exp_matrix = np.exp(matrix)\n","\n","    row_sums = np.sum(exp_matrix, axis=1, keepdims=True)\n","\n","    softmax_matrix = exp_matrix / row_sums\n","\n","    return softmax_matrix\n"]},{"cell_type":"code","execution_count":6,"id":"4a48c55b","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.239279Z","iopub.status.busy":"2024-05-17T16:20:02.238614Z","iopub.status.idle":"2024-05-17T16:20:02.246012Z","shell.execute_reply":"2024-05-17T16:20:02.244789Z"},"id":"Hke7DMuanm-m","outputId":"dca1420c-06e5-412e-824e-cdd142d89db8","papermill":{"duration":0.019783,"end_time":"2024-05-17T16:20:02.248339","exception":false,"start_time":"2024-05-17T16:20:02.228556","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Original Matrix:\n","[[1. 2. 3.]\n"," [4. 5. 6.]\n"," [7. 8. 9.]]\n","\n","Softmax Result:\n","[[0.09003057 0.24472847 0.66524096]\n"," [0.09003057 0.24472847 0.66524096]\n"," [0.09003057 0.24472847 0.66524096]]\n"]}],"source":["sample_matrix = np.array([[1.0, 2.0, 3.0],\n","                          [4.0, 5.0, 6.0],\n","                          [7.0, 8.0, 9.0]])\n","\n","softmax_result = softmax(sample_matrix)\n","\n","print(\"Original Matrix:\")\n","print(sample_matrix)\n","print(\"\\nSoftmax Result:\")\n","print(softmax_result)\n"]},{"cell_type":"markdown","id":"cd2ae4f4","metadata":{"id":"bBDQwgqYnvYi","papermill":{"duration":0.008702,"end_time":"2024-05-17T16:20:02.265813","exception":false,"start_time":"2024-05-17T16:20:02.257111","status":"completed"},"tags":[]},"source":["### Dot Product\n","- Create a function that implements dot product of two vectors. The input to the function should be two standard python lists. Identify the time taken to evaluate the dot product using a particular example of your choice.\n","- Now create another function that implements dot product of two vectors using `np.dot()` function. Identify the time taken to evaluate this dot product and compare it with the time taken in part a."]},{"cell_type":"code","execution_count":7,"id":"2e719327","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.28571Z","iopub.status.busy":"2024-05-17T16:20:02.285257Z","iopub.status.idle":"2024-05-17T16:20:02.291768Z","shell.execute_reply":"2024-05-17T16:20:02.290911Z"},"id":"txarKcwIoBhf","papermill":{"duration":0.018908,"end_time":"2024-05-17T16:20:02.29395","exception":false,"start_time":"2024-05-17T16:20:02.275042","status":"completed"},"tags":[]},"outputs":[],"source":["import time\n","import numpy as np\n","\n","def dot_product_python_lists(vector1, vector2):\n","    if len(vector1) != len(vector2):\n","        raise ValueError(\"Vectors must have the same length\")\n","\n","    dot_product = sum(x * y for x, y in zip(vector1, vector2))\n","    return dot_product\n","\n","def dot_product_numpy(vector1, vector2):\n","    dot_product = np.dot(vector1, vector2)\n","    return dot_product\n"]},{"cell_type":"code","execution_count":8,"id":"0396033c","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.314408Z","iopub.status.busy":"2024-05-17T16:20:02.313237Z","iopub.status.idle":"2024-05-17T16:20:02.322787Z","shell.execute_reply":"2024-05-17T16:20:02.321668Z"},"id":"1yoWAZQFoZ83","outputId":"b21ccde8-0ec8-4a6b-faa6-8f56ed055135","papermill":{"duration":0.022386,"end_time":"2024-05-17T16:20:02.325345","exception":false,"start_time":"2024-05-17T16:20:02.302959","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Dot Product using Python Lists: 35\n","Time taken with Python Lists: 6.198883056640625e-05 seconds\n","\n","Dot Product using np.dot(): 35\n","Time taken with np.dot(): 0.00013303756713867188 seconds\n"]}],"source":["example_vector1 = [1, 2, 3, 4, 5]\n","example_vector2 = [5, 4, 3, 2, 1]\n","\n","start_time_python_lists = time.time()\n","result_python_lists = dot_product_python_lists(example_vector1, example_vector2)\n","end_time_python_lists = time.time()\n","time_taken_python_lists = end_time_python_lists - start_time_python_lists\n","\n","start_time_numpy_dot = time.time()\n","result_numpy_dot = dot_product_numpy(np.array(example_vector1), np.array(example_vector2))\n","end_time_numpy_dot = time.time()\n","time_taken_numpy_dot = end_time_numpy_dot - start_time_numpy_dot\n","\n","print(\"Dot Product using Python Lists:\", result_python_lists)\n","print(\"Time taken with Python Lists:\", time_taken_python_lists, \"seconds\\n\")\n","\n","print(\"Dot Product using np.dot():\", result_numpy_dot)\n","print(\"Time taken with np.dot():\", time_taken_numpy_dot, \"seconds\")\n"]},{"cell_type":"markdown","id":"764dd3d6","metadata":{"id":"nHt5_btdodiM","papermill":{"duration":0.008848,"end_time":"2024-05-17T16:20:02.343349","exception":false,"start_time":"2024-05-17T16:20:02.334501","status":"completed"},"tags":[]},"source":["### Outer Product\n","- Create a function that implements outer product of two vectors. The input to the function should be two standard python lists. Identify the time taken to evaluate the outer product using a particular example of your choice.\n","- Now create another function that implements outer product of two vectors using `np.outer()` function. Identify the time taken to evaluate this dot product and compare it with the time taken in part a."]},{"cell_type":"code","execution_count":9,"id":"b0dfdf12","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.364106Z","iopub.status.busy":"2024-05-17T16:20:02.363273Z","iopub.status.idle":"2024-05-17T16:20:02.36976Z","shell.execute_reply":"2024-05-17T16:20:02.368865Z"},"id":"0n2cY50sobA1","papermill":{"duration":0.019652,"end_time":"2024-05-17T16:20:02.372228","exception":false,"start_time":"2024-05-17T16:20:02.352576","status":"completed"},"tags":[]},"outputs":[],"source":["import time\n","import numpy as np\n","\n","def outer_product_python_lists(vector1, vector2):\n","    outer_product = [[x * y for y in vector2] for x in vector1]\n","    return outer_product\n","\n","def outer_product_numpy(vector1, vector2):\n","    outer_product = np.outer(vector1, vector2)\n","    return outer_product\n"]},{"cell_type":"code","execution_count":10,"id":"5246b1cb","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.393237Z","iopub.status.busy":"2024-05-17T16:20:02.392461Z","iopub.status.idle":"2024-05-17T16:20:02.405036Z","shell.execute_reply":"2024-05-17T16:20:02.403857Z"},"id":"KLFvaI7AorwR","outputId":"ea05c3da-fc9e-42f5-e535-d0d781bb6587","papermill":{"duration":0.025701,"end_time":"2024-05-17T16:20:02.407463","exception":false,"start_time":"2024-05-17T16:20:02.381762","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Outer Product using Python Lists:\n","[[5, 4, 3, 2, 1], [10, 8, 6, 4, 2], [15, 12, 9, 6, 3], [20, 16, 12, 8, 4], [25, 20, 15, 10, 5]]\n","Time taken with Python Lists: 7.796287536621094e-05 seconds\n","\n","Outer Product using np.outer():\n","[[ 5  4  3  2  1]\n"," [10  8  6  4  2]\n"," [15 12  9  6  3]\n"," [20 16 12  8  4]\n"," [25 20 15 10  5]]\n","Time taken with np.outer(): 0.001615285873413086 seconds\n"]}],"source":["example_vector1 = [1, 2, 3, 4, 5]\n","example_vector2 = [5, 4, 3, 2, 1]\n","\n","start_time_python_lists = time.time()\n","result_python_lists = outer_product_python_lists(example_vector1, example_vector2)\n","end_time_python_lists = time.time()\n","time_taken_python_lists = end_time_python_lists - start_time_python_lists\n","\n","start_time_numpy_outer = time.time()\n","result_numpy_outer = outer_product_numpy(np.array(example_vector1), np.array(example_vector2))\n","end_time_numpy_outer = time.time()\n","time_taken_numpy_outer = end_time_numpy_outer - start_time_numpy_outer\n","\n","print(\"Outer Product using Python Lists:\")\n","print(result_python_lists)\n","print(\"Time taken with Python Lists:\", time_taken_python_lists, \"seconds\\n\")\n","\n","print(\"Outer Product using np.outer():\")\n","print(result_numpy_outer)\n","print(\"Time taken with np.outer():\", time_taken_numpy_outer, \"seconds\")\n"]},{"cell_type":"markdown","id":"6a7a6127","metadata":{"id":"ZO2U0wZOoxBA","papermill":{"duration":0.0094,"end_time":"2024-05-17T16:20:02.42642","exception":false,"start_time":"2024-05-17T16:20:02.41702","status":"completed"},"tags":[]},"source":["### Loss Functions:\n","- Create a function that takes two vectors in the form of standard python lists and returns the L1 loss.\n","- Now create another function that returns L1 loss but uses NumPy arrays instead of standard python list. Compare the two approaches.\n","- Create a function that takes two vectors in the form of standard python lists and returns the L2 loss.\n","- Now create another function that returns L2 loss but uses NumPy arrays instead of standard python list. Compare the two approaches."]},{"cell_type":"code","execution_count":11,"id":"bd0589c0","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.447094Z","iopub.status.busy":"2024-05-17T16:20:02.446702Z","iopub.status.idle":"2024-05-17T16:20:02.456769Z","shell.execute_reply":"2024-05-17T16:20:02.455601Z"},"id":"Pu-BznUBosug","papermill":{"duration":0.023147,"end_time":"2024-05-17T16:20:02.458986","exception":false,"start_time":"2024-05-17T16:20:02.435839","status":"completed"},"tags":[]},"outputs":[],"source":["import numpy as np\n","\n","def l1_loss_python_lists(vector1, vector2):\n","    if len(vector1) != len(vector2):\n","        raise ValueError(\"Vectors must have the same length\")\n","\n","    l1_loss = sum(abs(x - y) for x, y in zip(vector1, vector2))\n","    return l1_loss\n","\n","def l1_loss_numpy(vector1, vector2):\n","    if len(vector1) != len(vector2):\n","        raise ValueError(\"Vectors must have the same length\")\n","\n","    l1_loss = np.sum(np.abs(np.array(vector1) - np.array(vector2)))\n","    return l1_loss\n","\n","def l2_loss_python_lists(vector1, vector2):\n","    if len(vector1) != len(vector2):\n","        raise ValueError(\"Vectors must have the same length\")\n","\n","    l2_loss = sum((x - y)**2 for x, y in zip(vector1, vector2))\n","    return l2_loss**0.5\n","\n","def l2_loss_numpy(vector1, vector2):\n","    if len(vector1) != len(vector2):\n","        raise ValueError(\"Vectors must have the same length\")\n","\n","    l2_loss = np.linalg.norm(np.array(vector1) - np.array(vector2))\n","    return l2_loss\n"]},{"cell_type":"code","execution_count":12,"id":"05a2240d","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.480066Z","iopub.status.busy":"2024-05-17T16:20:02.479367Z","iopub.status.idle":"2024-05-17T16:20:02.48922Z","shell.execute_reply":"2024-05-17T16:20:02.487915Z"},"id":"uRSCkR0xpCGZ","outputId":"5cbdc1a9-48ef-4992-f8d0-5f6a2ed5cf45","papermill":{"duration":0.022967,"end_time":"2024-05-17T16:20:02.491437","exception":false,"start_time":"2024-05-17T16:20:02.46847","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["L1 Loss using Python Lists: 12\n","L1 Loss using NumPy Arrays: 12\n","\n","L2 Loss using Python Lists: 6.324555320336759\n","L2 Loss using NumPy Arrays: 6.324555320336759\n"]}],"source":["vector1 = [1, 2, 3, 4, 5]\n","vector2 = [5, 4, 3, 2, 1]\n","\n","l1_loss_result_python_lists = l1_loss_python_lists(vector1, vector2)\n","print(\"L1 Loss using Python Lists:\", l1_loss_result_python_lists)\n","\n","l1_loss_result_numpy = l1_loss_numpy(np.array(vector1), np.array(vector2))\n","print(\"L1 Loss using NumPy Arrays:\", l1_loss_result_numpy)\n","\n","l2_loss_result_python_lists = l2_loss_python_lists(vector1, vector2)\n","print(\"\\nL2 Loss using Python Lists:\", l2_loss_result_python_lists)\n","\n","l2_loss_result_numpy = l2_loss_numpy(np.array(vector1), np.array(vector2))\n","print(\"L2 Loss using NumPy Arrays:\", l2_loss_result_numpy)\n"]},{"cell_type":"markdown","id":"cb27d6db","metadata":{"id":"l27quLMypT8C","papermill":{"duration":0.00955,"end_time":"2024-05-17T16:20:02.510839","exception":false,"start_time":"2024-05-17T16:20:02.501289","status":"completed"},"tags":[]},"source":["### Perform Matrix and Matrix Addition:\n","- Create a function that performs matrix and matrix addition by using standard python data structures only.\n","- Create a function that performs matrix and matrix addition by using NumPy arrays."]},{"cell_type":"code","execution_count":13,"id":"22fa1649","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.532257Z","iopub.status.busy":"2024-05-17T16:20:02.53149Z","iopub.status.idle":"2024-05-17T16:20:02.540135Z","shell.execute_reply":"2024-05-17T16:20:02.539062Z"},"id":"u0_o4UJwpMTx","papermill":{"duration":0.021879,"end_time":"2024-05-17T16:20:02.542374","exception":false,"start_time":"2024-05-17T16:20:02.520495","status":"completed"},"tags":[]},"outputs":[],"source":["import numpy as np\n","\n","def matrix_addition_python(matrix1, matrix2):\n","    if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):\n","        raise ValueError(\"Matrices must have the same dimensions for addition\")\n","\n","    result_matrix = [[matrix1[i][j] + matrix2[i][j] for j in range(len(matrix1[0]))] for i in range(len(matrix1))]\n","    return result_matrix\n","\n","def matrix_addition_numpy(matrix1, matrix2):\n","    if matrix1.shape != matrix2.shape:\n","        raise ValueError(\"Matrices must have the same dimensions for addition\")\n","\n","    result_matrix = matrix1 + matrix2\n","    return result_matrix\n","\n"]},{"cell_type":"code","execution_count":14,"id":"2682371e","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.563432Z","iopub.status.busy":"2024-05-17T16:20:02.562985Z","iopub.status.idle":"2024-05-17T16:20:02.571307Z","shell.execute_reply":"2024-05-17T16:20:02.570262Z"},"id":"QA8Nm1HVpc68","outputId":"87efa371-31a5-43ac-d47a-ec08faf5fa59","papermill":{"duration":0.022132,"end_time":"2024-05-17T16:20:02.574137","exception":false,"start_time":"2024-05-17T16:20:02.552005","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Matrix Addition using Python Lists:\n","[10, 10, 10]\n","[10, 10, 10]\n","[10, 10, 10]\n","\n","Matrix Addition using NumPy Arrays:\n","[[10 10 10]\n"," [10 10 10]\n"," [10 10 10]]\n"]}],"source":["matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n","matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]\n","\n","result_matrix_python = matrix_addition_python(matrix1, matrix2)\n","print(\"Matrix Addition using Python Lists:\")\n","for row in result_matrix_python:\n","    print(row)\n","\n","result_matrix_numpy = matrix_addition_numpy(np.array(matrix1), np.array(matrix2))\n","print(\"\\nMatrix Addition using NumPy Arrays:\")\n","print(result_matrix_numpy)\n"]},{"cell_type":"markdown","id":"e9ada3c0","metadata":{"id":"yYbp9TospruS","papermill":{"duration":0.010511,"end_time":"2024-05-17T16:20:02.594934","exception":false,"start_time":"2024-05-17T16:20:02.584423","status":"completed"},"tags":[]},"source":["### Perform Matrix and Vector Multiplication:\n","- Create a function that performs matrix and vector multiplication by using standard python data structures only.\n","- Create a function that performs matrix and vector multiplication by using NumPy arrays."]},{"cell_type":"code","execution_count":15,"id":"5939ae66","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.624798Z","iopub.status.busy":"2024-05-17T16:20:02.624047Z","iopub.status.idle":"2024-05-17T16:20:02.63277Z","shell.execute_reply":"2024-05-17T16:20:02.631527Z"},"id":"lriYRLd8pmgv","papermill":{"duration":0.027614,"end_time":"2024-05-17T16:20:02.636184","exception":false,"start_time":"2024-05-17T16:20:02.60857","status":"completed"},"tags":[]},"outputs":[],"source":["import numpy as np\n","\n","def matrix_vector_multiplication_python(matrix, vector):\n","    if len(matrix[0]) != len(vector):\n","        raise ValueError(\"Number of columns in the matrix must be equal to the length of the vector\")\n","\n","    result_vector = [sum(matrix[i][j] * vector[j] for j in range(len(vector))) for i in range(len(matrix))]\n","    return result_vector\n","\n","def matrix_vector_multiplication_numpy(matrix, vector):\n","    if matrix.shape[1] != len(vector):\n","        raise ValueError(\"Number of columns in the matrix must be equal to the length of the vector\")\n","\n","    result_vector = np.dot(matrix, vector)\n","    return result_vector\n"]},{"cell_type":"code","execution_count":16,"id":"3bdd4212","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.66667Z","iopub.status.busy":"2024-05-17T16:20:02.665334Z","iopub.status.idle":"2024-05-17T16:20:02.675365Z","shell.execute_reply":"2024-05-17T16:20:02.673744Z"},"id":"CfGF4-kOqjIi","outputId":"3fd13177-a60d-4495-d366-ecc01f682e2d","papermill":{"duration":0.027299,"end_time":"2024-05-17T16:20:02.677656","exception":false,"start_time":"2024-05-17T16:20:02.650357","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Matrix and Vector Multiplication using Python Lists: [20, 47, 74]\n","Matrix and Vector Multiplication using NumPy Arrays: [20 47 74]\n"]}],"source":["matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n","vector = [2, 3, 4]\n","\n","result_vector_python = matrix_vector_multiplication_python(matrix, vector)\n","print(\"Matrix and Vector Multiplication using Python Lists:\", result_vector_python)\n","\n","result_vector_numpy = matrix_vector_multiplication_numpy(np.array(matrix), np.array(vector))\n","print(\"Matrix and Vector Multiplication using NumPy Arrays:\", result_vector_numpy)\n"]},{"cell_type":"markdown","id":"b52923a5","metadata":{"id":"iFVxUJAJqn7B","papermill":{"duration":0.00982,"end_time":"2024-05-17T16:20:02.697857","exception":false,"start_time":"2024-05-17T16:20:02.688037","status":"completed"},"tags":[]},"source":["### Perform Matrix and Matrix Multiplication:\n","- Create a function that performs matrix and matrix multiplication by using standard python data structures only.\n","- Create a function that performs matrix and matrix multiplication by using NumPy arrays."]},{"cell_type":"code","execution_count":17,"id":"2f2297c6","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.720496Z","iopub.status.busy":"2024-05-17T16:20:02.719988Z","iopub.status.idle":"2024-05-17T16:20:02.729024Z","shell.execute_reply":"2024-05-17T16:20:02.727891Z"},"id":"kubNkK3Fqkwc","papermill":{"duration":0.023536,"end_time":"2024-05-17T16:20:02.731542","exception":false,"start_time":"2024-05-17T16:20:02.708006","status":"completed"},"tags":[]},"outputs":[],"source":["def matrix_multiplication_python(matrix1, matrix2):\n","    if len(matrix1[0]) != len(matrix2):\n","        raise ValueError(\"Number of columns in the first matrix must be equal to the number of rows in the second matrix\")\n","\n","    result_matrix = [[sum(matrix1[i][k] * matrix2[k][j] for k in range(len(matrix2))) for j in range(len(matrix2[0]))] for i in range(len(matrix1))]\n","    return result_matrix\n","\n","import numpy as np\n","\n","def matrix_multiplication_numpy(matrix1, matrix2):\n","    if matrix1.shape[1] != matrix2.shape[0]:\n","        raise ValueError(\"Number of columns in the first matrix must be equal to the number of rows in the second matrix\")\n","\n","    result_matrix = np.dot(matrix1, matrix2)\n","    return result_matrix\n"]},{"cell_type":"code","execution_count":18,"id":"cd256645","metadata":{"execution":{"iopub.execute_input":"2024-05-17T16:20:02.754863Z","iopub.status.busy":"2024-05-17T16:20:02.753592Z","iopub.status.idle":"2024-05-17T16:20:02.763878Z","shell.execute_reply":"2024-05-17T16:20:02.762705Z"},"id":"gZFtvH5XqvBW","outputId":"b14ec753-2dce-482b-914e-2d9ed4b6274a","papermill":{"duration":0.025509,"end_time":"2024-05-17T16:20:02.767551","exception":false,"start_time":"2024-05-17T16:20:02.742042","status":"completed"},"tags":[]},"outputs":[{"name":"stdout","output_type":"stream","text":["Matrix and Matrix Multiplication using Python Lists:\n","[30, 24, 18]\n","[84, 69, 54]\n","[138, 114, 90]\n","\n","Matrix and Matrix Multiplication using NumPy Arrays:\n","[[ 30  24  18]\n"," [ 84  69  54]\n"," [138 114  90]]\n"]}],"source":["matrix1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n","matrix2 = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]\n","\n","result_matrix_python = matrix_multiplication_python(matrix1, matrix2)\n","print(\"Matrix and Matrix Multiplication using Python Lists:\")\n","for row in result_matrix_python:\n","    print(row)\n","\n","result_matrix_numpy = matrix_multiplication_numpy(np.array(matrix1), np.array(matrix2))\n","print(\"\\nMatrix and Matrix Multiplication using NumPy Arrays:\")\n","print(result_matrix_numpy)\n"]},{"cell_type":"code","execution_count":null,"id":"b6d4dba8","metadata":{"papermill":{"duration":0.014777,"end_time":"2024-05-17T16:20:02.79748","exception":false,"start_time":"2024-05-17T16:20:02.782703","status":"completed"},"tags":[]},"outputs":[],"source":[]},{"cell_type":"markdown","id":"1bedd29f","metadata":{"papermill":{"duration":0.010166,"end_time":"2024-05-17T16:20:02.821591","exception":false,"start_time":"2024-05-17T16:20:02.811425","status":"completed"},"tags":[]},"source":["**Find More Labs**\n","\n","This lab is from my Machine Learning Course, that is a part of my [Software Engineering](https://seecs.nust.edu.pk/program/bachelor-of-software-engineering-for-fall-2021-onward) Degree at [NUST](https://nust.edu.pk).\n","\n","The content in the provided list of notebooks covers a range of topics in **machine learning** and **data analysis** implemented from scratch or using popular libraries like **NumPy**, **pandas**, **scikit-learn**, **seaborn**, and **matplotlib**. It includes introductory materials on NumPy showcasing its efficiency for mathematical operations, **linear regression**, **logistic regression**, **decision trees**, **K-nearest neighbors (KNN)**, **support vector machines (SVM)**, **Naive Bayes**, **K-means** clustering, principle component analysis (**PCA**), and **neural networks** with **backpropagation**. Each notebook demonstrates practical implementation and application of these algorithms on various datasets such as the **California Housing** Dataset, **MNIST** dataset, **Iris** dataset, **Auto-MPG** dataset, and the **UCI Adult Census Income** dataset. Additionally, it covers topics like **gradient descent optimization**, model evaluation metrics (e.g., **accuracy, precision, recall, f1 score**), **regularization** techniques (e.g., **Lasso**, **Ridge**), and **data visualization**.\n","\n","| Title                                                                                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n","| ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n","| [01 - Intro to Numpy](https://www.kaggle.com/code/sacrum/ml-labs-01-intro-to-numpy)                                     | The notebook demonstrates NumPy's efficiency for mathematical operations like array `reshaping`, `sigmoid`, `softmax`, `dot` and `outer products`, `L1 and L2 losses`, and matrix operations. It highlights NumPy's superiority over standard Python lists in speed and convenience for scientific computing and machine learning tasks.                                                                                                                                                                                              |\n","| [02 - Linear Regression From Scratch](https://www.kaggle.com/code/sacrum/ml-labs-02-linear-regression-from-scratch)     | This notebook implements `linear regression` and `gradient descent` from scratch in Python using `NumPy`, focusing on predicting house prices with the `California Housing Dataset`. It defines functions for prediction, `MSE` calculation, and gradient computation. Batch gradient descent is used for optimization. The dataset is loaded, scaled, and split. `Batch, stochastic, and mini-batch gradient descents` are applied with varying hyperparameters. Finally, the MSEs of the predictions from each method are compared. |\n","| [03 - Logistic Regression from Scratch](https://www.kaggle.com/code/sacrum/ml-labs-03-logistic-regression-from-scratch) | This notebook outlines the implementation of `logistic regression` from scratch in Python using `NumPy`, including functions for prediction, loss calculation, gradient computation, and batch `gradient descent` optimization, applied to the `MNIST` dataset for handwritten digit recognition and `Iris` data. And also inclues metrics like `accuracy`, `precision`, `recall`, `f1 score`                                                                                                                                         |\n","| [04 - Auto-MPG Regression](https://www.kaggle.com/code/sacrum/ml-labs-04-auto-mpg-regression)                           | The notebook uses `pandas` for data manipulation, `seaborn` and `matplotlib` for visualization, and `sklearn` for `linear regression` and `regularization` techniques (`Lasso` and `Ridge`). It includes data loading, processing, visualization, model training, and evaluation on the `Auto-MPG dataset`.                                                                                                                                                                                                                           |\n","| [05 - Desicion Trees from Scratch](https://www.kaggle.com/code/sacrum/ml-labs-05-desicion-trees-from-scratch)           | In this notebook, `DecisionTree` algorithm has been implmented from scratch and applied on dummy dataset                                                                                                                                                                                                                                                                                                                                                                                                                              |\n","| [06 - KNN from Scratch](https://www.kaggle.com/code/sacrum/ml-labs-06-knn-from-scratch)                                 | In this notebook, `K-Nearest Neighbour` algorithm has been implemented from scratch and compared with KNN provided in scikit-learn package                                                                                                                                                                                                                                                                                                                                                                                            |\n","| [07 - SVM](https://www.kaggle.com/code/sacrum/ml-labs-07-svm)                                                           | This notebook implements `SVM classifier` on `Iris Dataset`                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |\n","| [08 - Naive Bayes](https://www.kaggle.com/code/sacrum/ml-labs-08-naive-bayes)                                           | This notebook trains `Naive Bayes` and compares it with other algorithms `Decision Trees`, `SVM` and `Logistic Regression`                                                                                                                                                                                                                                                                                                                                                                                                            |\n","| [09 - K-means](https://www.kaggle.com/code/sacrum/ml-labs-09-k-means)                                                   | In this notebook `K-means` algorithm has been implemented using `scikit-learn` and different values of `k` are compared to understand the `elbow method` in `Calinski Harabasz Scores`                                                                                                                                                                                                                                                                                                                                                |\n","| [10 - UCI Adult Census Income](https://www.kaggle.com/code/sacrum/ml-labs-10-uci-adult-census-income)                   | Here I have used the UCI Adult Income dataset and applied different machine learning algorithms to find the best model configuration for predicting salary from the given information                                                                                                                                                                                                                                                                                                                                                 |\n","| [11 - PCA](https://www.kaggle.com/code/sacrum/ml-labs-11-pca)                                                           | `Principle Component Analysis` implemented from scratch                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |\n","| [12 - Neural Networks](https://www.kaggle.com/code/sacrum/ml-labs-12-neural-networks)                                   | This code implements neural networks with back propagation from scratch                                                                                                                                                                                                                                                                                                                                                                                                                                                               |"]}],"metadata":{"colab":{"provenance":[]},"kaggle":{"accelerator":"none","dataSources":[],"dockerImageVersionId":30698,"isGpuEnabled":false,"isInternetEnabled":true,"language":"python","sourceType":"notebook"},"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.10.13"},"papermill":{"default_parameters":{},"duration":4.256136,"end_time":"2024-05-17T16:20:03.252739","environment_variables":{},"exception":null,"input_path":"__notebook__.ipynb","output_path":"__notebook__.ipynb","parameters":{},"start_time":"2024-05-17T16:19:58.996603","version":"2.5.0"}},"nbformat":4,"nbformat_minor":5}