Intro_to_python.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjT9BF9dwP1U"
      },
      "source": [
        "# Intro to Python\n",
        "\n",
        "Click the little play button in the cell below!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oxaZuMnWwPj7"
      },
      "outputs": [],
      "source": [
        "print(\"Hello world!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uYCYtFt5iJOy"
      },
      "source": [
        "Congratulations! You just ran your first python program!\n",
        "\n",
        "Python is a high-level, interpreted programming language known for its simplicity, readability, and versatility. As an interpreted language, Python has an interpreter that reads the code and executes it line by line, converting it into bytecode, which is then executed by the Python Virtual Machine (R and MatLab are also interpreted languages). This process allows for flexibility and ease of development. It was created by [Guido van Rossum](https://pythoninstitute.org/about-python#:~:text=Python%20was%20created%20by%20Guido,called%20Monty%20Python's%20Flying%20Circus.) and first released in 1991. Python emphasizes code readability with its clear and concise syntax, which resembles natural language, making it accessible to beginners and experienced programmers alike.\n",
        "\n",
        "Python's popularity stems from several key factors:\n",
        "\n",
        "* **Ease of Learning and Use:** Python's simple syntax and readability make it easy to learn, understand, and write code. Its beginner-friendly nature attracts a wide range of developers, from novices to seasoned professionals.\n",
        "\n",
        "* **Versatility:** Python is a multipurpose language suitable for various applications, including web development, data analysis, artificial intelligence, machine learning, scientific computing, automation, and more. Its extensive standard library and vast ecosystem of third-party packages contribute to its versatility.\n",
        "\n",
        "* **Community and Ecosystem:** Python boasts a large and active community of developers worldwide. This vibrant community contributes to the development of libraries, frameworks, and tools, enriching the Python ecosystem. The availability of numerous resources, forums, and tutorials facilitates learning and collaboration.\n",
        "\n",
        "* **Scalability and Performance:** While Python is often criticized for its performance compared to lower-level languages like C or C++, its performance has improved significantly over the years. Additionally, Python's simplicity allows for rapid development, making it *well-suited for prototyping and iterating on ideas quickly*.\n",
        "\n",
        "* **Cross-Platform Compatibility:** Python is platform-independent, meaning code written in Python can run on various operating systems, including Windows, macOS, and Linux, with minimal modifications.\n",
        "\n",
        "Overall, Python's combination of simplicity, versatility, community support, and scalability has contributed to its widespread adoption and enduring popularity among developers across different industries and domains.\n",
        "\n",
        "\n",
        "\n",
        "## Using Python and Jupyter Notebooks\n",
        "\n",
        "\n",
        "For this Demo we make use of Google Colab and Jupyter Notebooks.\n",
        "\n",
        "Jupyter Notebook is an open-source web application that allows you to create and share documents containing live code, equations, visualizations, and narrative text making it popular among researchers, educators, and data scientists.\n",
        "\n",
        "Some key features of Jupyter Notebooks include:\n",
        "\n",
        "* **Interactive Computing:** Jupyter Notebook provides an interactive computing environment where you can write and execute code in cells, allowing for rapid experimentation and iterative development.\n",
        "\n",
        "* **Rich Output:** Jupyter Notebook supports rich output formats, including HTML, images, videos, and interactive widgets, enabling the creation of dynamic and visually appealing documents.\n",
        "\n",
        "* **Markdown Support:** In addition to code cells, Jupyter Notebook allows you to include markdown cells for writing formatted text, equations, and documentation alongside your code. e.g\n",
        "\n",
        "$$\n",
        "\\int_{a}^{b} x^2 \\, dx\n",
        "$$\n",
        "(A nice Markdown cheat sheet from kaggle can be [here](https://www.kaggle.com/code/cuecacuela/the-ultimate-markdown-cheat-sheet))\n",
        "* **Data Visualization:** Jupyter Notebook integrates with libraries such as Matplotlib, Seaborn, and Plotly for creating interactive visualizations directly within the notebook.\n",
        "\n",
        "* **Collaboration and Sharing:** Jupyter Notebook documents can be easily shared with others via email, Dropbox, GitHub, or the Jupyter Notebook Viewer, facilitating collaboration and reproducibility of research findings.\n",
        "\n",
        "**Google Colab** (Colaboratory) is a cloud-based Jupyter Notebook environment provided by Google, which allows you to write, execute, and share Python code directly in your web browser. It offers free access to GPU and TPU resources, making it particularly useful for training machine learning models and conducting data analysis tasks that require significant computational power. For more resources on using use this Google Colab and Markdown check out this great [cheat sheet](https://colab.research.google.com/github/Tanu-N-Prabhu/Python/blob/master/Cheat_sheet_for_Google_Colab.ipynb) by Tanu-N-Prabhu.\n",
        "\n",
        "If you dont want to use Google colab you can also [install Juypter](https://jupyter.org/install) locally. Here is little [cheet sheet](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Jupyter_Notebook_Cheat_Sheet.pdf) on using Jupyter locally.\n",
        "## Python's Basic Syntax\n",
        "\n",
        "* **Comments**:\n",
        "\n",
        "Single-line comments start with a `#`.\n",
        "Multi-line comments are enclosed within triple quotes (`'''` or `\"\"\"`).\n",
        "\n",
        "* **Indentation**:\n",
        "\n",
        "Python uses indentation to define blocks of code (e.g., loops, conditional statements, functions).\n",
        "Indentation is typically four spaces or one tab.\n",
        "\n",
        "* **Variables and Data Types**:\n",
        "\n",
        "  * Variables are containers for storing data.\n",
        "  * Python is dynamically typed, meaning you don't need to declare the data type explicitly.\n",
        "  * Common data types include integers (`int`), floats (`float`), strings (`str`), booleans (`bool`), lists (`list`), dictionaries (`dict`), and sets (`sets`). *Use the function* `type( )` *to check the data type of an object.*\n",
        "  \n",
        "* **Basic Arithmetic Operations**:\n",
        "\n",
        "  * Addition (`+`), subtraction (`-`), multiplication (`*`), division (`/`), modulus (`%`), exponentiation (`**`), and floor division (`//`).\n",
        "* **Strings**:\n",
        "\n",
        "Strings are sequences of characters enclosed in single (') or double (\") quotes.\n",
        "String concatenation using +, repetition using *, and string interpolation with f-strings (formatted strings). For example\n",
        "\n",
        "```python\n",
        " x = 2\n",
        " print(f\" x = {x}\")\n",
        "```\n",
        "ouputs\n",
        "```\n",
        "x=2\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BXMl-XQ4hlYm"
      },
      "outputs": [],
      "source": [
        "# Basic Syntax\n",
        "# Variable assignment\n",
        "x = 3\n",
        "y = 10\n",
        "\n",
        "# Arithmetic operations\n",
        "sum_result = x + y\n",
        "difference_result = x - y\n",
        "product_result = x * y\n",
        "quotient_result = x / y\n",
        "modulo_result = y%x\n",
        "exponentiation_result = x**y\n",
        "# Print results\n",
        "print(f\"Sum: {sum_result}\")\n",
        "print(f\"Difference: {difference_result}\")\n",
        "print(f\"Product: {product_result}\")\n",
        "print(f\"Quotient: {quotient_result}\")\n",
        "print(f\"Modulus: {modulo_result}\")\n",
        "print(f\"Exponentiation: {exponentiation_result}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AUBFBlRvnJ8h"
      },
      "source": [
        "**Exercise.**\n",
        "\n",
        "Compute $$\n",
        "36\\  \\text{mod}\\  5^2\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FqEbrWLqmlAG"
      },
      "outputs": [],
      "source": [
        "# Write code here."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "ans = 36 % (5**2)\n",
        "print(f\"answer = {ans}\")\n"
      ],
      "metadata": {
        "id": "V7vQHtzSDkuq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ECFe3wDfqQD2"
      },
      "source": [
        "## Data Structures\n",
        "In Python, data structures are specialized formats for organizing, storing, and managing data efficiently. They provide a way to store and manipulate collections of data, and Python offers several built-in data structures, each with its own characteristics and use cases.Understanding when and how to use each data structure is essential for writing efficient and effective Python code.\n",
        "\n",
        "**Lists**:\n",
        "\n",
        "* Lists are *ordered collections of items*, represented by square brackets `[ ]`.\n",
        "* Lists are mutable, meaning they can be modified after creation by adding, removing, or changing elements.\n",
        "* Lists can contain elements of different data types, including integers, floats, strings, and even other lists.\n",
        "* Elements in a list are accessed using zero-based indexing, and negative indices can be used to access elements from the end of the list.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OJ5MhNvCqPfJ"
      },
      "outputs": [],
      "source": [
        "#Example use of lists\n",
        "\n",
        "# Creating a list\n",
        "fruits = [\"apple\", \"banana\", \"cherry\", \"date\"]\n",
        "print(fruits)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Accessing elements\n",
        "print(\"First:\", fruits[0])\n",
        "print(\"Last:\", fruits[-1])"
      ],
      "metadata": {
        "id": "MX8Mzy1OARMB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TZyqIz3ZsQ2N"
      },
      "outputs": [],
      "source": [
        "# Modifying elements\n",
        "fruits[1] = \"orange\"\n",
        "print(fruits)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iRa9-_FyAvYp"
      },
      "outputs": [],
      "source": [
        "# Adding elements\n",
        "fruits.append(\"grape\")\n",
        "print(fruits)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ekmoZxJKsMHe"
      },
      "outputs": [],
      "source": [
        "# Removing elements\n",
        "del fruits[2]"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Iterating over elements\n",
        "print(\"Items in list:\")\n",
        "for fruit in fruits:\n",
        "    print(fruit)"
      ],
      "metadata": {
        "id": "goOKn8-zAYvz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S3DdEKV0seaQ"
      },
      "outputs": [],
      "source": [
        "# Length of the list\n",
        "print(\"Length of list:\", len(fruits))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0htFDeQirvlY"
      },
      "source": [
        "\n",
        "**Sets**:\n",
        "\n",
        "* Sets are *unordered collections of unique elements*, represented by curly braces `{ }`.\n",
        "* Sets are mutable\n",
        "* Sets support mathematical set operations such as union, intersection, difference, and symmetric difference.\n",
        "* Elements in a set are not indexed, so you cannot access elements by index or slice a set.\n",
        "Sets are commonly used for membership testing, removing duplicates from lists, and performing set operations."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1bEGbasZrzN_"
      },
      "outputs": [],
      "source": [
        "# Example use of sets\n",
        "\n",
        "# Creating a set\n",
        "set1 = {1, 2, 3, 4, 5}\n",
        "set2 = {4, 5, 6, 7, 8}\n",
        "\n",
        "print(set1)\n",
        "print(set2)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding elements to a set\n",
        "set1.add(6)\n",
        "\n",
        "# Removing elements from a set\n",
        "set2.remove(8)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "7FsNtX9mAfDO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JDoG_-alsvyV"
      },
      "outputs": [],
      "source": [
        "# Membership testing\n",
        "# Is 8 still in set2?\n",
        "print(\"Is 8 in set2?\", 8 in set2)\n",
        "\n",
        "# Is 3 in set1?\n",
        "print(\"Is 3 in set1?\", 3 in set1)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZctgF0wps6Lx"
      },
      "outputs": [],
      "source": [
        "# Set operations\n",
        "union_of_sets = set1.union(set2)\n",
        "intersection_of_sets = set1.intersection(set2)\n",
        "difference_of_sets = set1.difference(set2)\n",
        "print(\"Union of set1 and set2:\", union_of_sets )\n",
        "print(\"Intersection of set1 and set2:\", intersection_of_sets )\n",
        "print(\"Difference of set1 and set2:\", difference_of_sets  )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N1ipQLbYtQF6"
      },
      "source": [
        "**Exercise**:\n",
        "Remove duplicates from the list `[1, 2, 3, 4, 1, 2, 5]`"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here"
      ],
      "metadata": {
        "id": "UZcQtlnWDaLo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2EiiZ3_KtMSE",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "# @title Solution\n",
        "\n",
        "# Removing duplicates from a list\n",
        "list_with_duplicates = [1, 2, 3, 4, 1, 2, 5]\n",
        "set_of_unique = set(list_with_duplicates)\n",
        "list_of_unique = list(set_of_unique)\n",
        "print(list_of_unique)\n",
        "\n",
        "# Another possible solution\n",
        "temp_set = set()\n",
        "for item in list_with_duplicates:\n",
        "  temp_set.add(item)\n",
        "\n",
        "list_of_unique = list(temp_set)\n",
        "print(list_of_unique)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kRle7z_lvjek"
      },
      "source": [
        "**Strings**:\n",
        "\n",
        "* Strings are sequences of characters, enclosed in single (`'`) or double (`\"`) quotes.\n",
        "* They are immutable, meaning you cannot change them after creation.\n",
        "* Strings support various operations like concatenation, slicing, and formatting."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6VKGlkkiv5BV"
      },
      "outputs": [],
      "source": [
        "# Example use of strings\n",
        "\n",
        "# Define a string\n",
        "greeting = \"Hello, World!\"\n",
        "\n",
        "# Accessing characters in a string\n",
        "print(\"First character:\", greeting[0])\n",
        "print(\"Last character:\", greeting[-1])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rFdjrxJSwKM-"
      },
      "outputs": [],
      "source": [
        "# Slicing strings\n",
        "print(\"Substring:\", greeting[7:12])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "izyRQFwrlq7M"
      },
      "outputs": [],
      "source": [
        "\n",
        "# String concatenation\n",
        "name = \"Alice\"\n",
        "message = \"Welcome, \" + name + \"!\"\n",
        "print(message)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7WHvxojilt5i"
      },
      "outputs": [],
      "source": [
        "# String formatting with f-strings\n",
        "age = 25\n",
        "formatted_message = f\"Hello, {name}! You are {age} years old.\"\n",
        "print(formatted_message)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vzY8wTJzl3g2"
      },
      "outputs": [],
      "source": [
        "# String methods\n",
        "print(\"Uppercase:\", greeting.upper())\n",
        "print(\"Lowercase:\", greeting.lower())\n",
        "print(\"Length:\", len(greeting))\n",
        "print(\"Split:\", greeting.split(\",\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VhCvgT8il5q6"
      },
      "outputs": [],
      "source": [
        "# Checking substrings\n",
        "print(\"Contains 'World'?\", \"World\" in greeting)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7OruIIPNl7ry"
      },
      "outputs": [],
      "source": [
        "# String repetition\n",
        "stars = \"*\" * 10\n",
        "print(stars)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rshxCNgUl8RO"
      },
      "outputs": [],
      "source": [
        "# Removing whitespace\n",
        "text_with_spaces = \"  Hello, World!  \"\n",
        "print(\"Stripped:\", text_with_spaces.strip())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Snaqj5KYl9bK"
      },
      "outputs": [],
      "source": [
        "# Finding substring\n",
        "index = greeting.find(\"World\")\n",
        "print(\"Index of 'World':\", index)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sBwt2ocJr1WH"
      },
      "source": [
        "\n",
        "**Dictionaries**:\n",
        "\n",
        "* Dictionaries are unordered collections of key-value pairs, represented by curly braces `{ }`.\n",
        "Each key-value pair in a dictionary is separated by a colon : and keys and values are separated by commas.\n",
        "* Keys in a dictionary must be unique and immutable (such as strings, numbers, or tuples), while values can be of any data type and mutable.\n",
        "* Dictionaries are mutable, meaning you can add, remove, or modify key-value pairs after creation.\n",
        "* Elements in a dictionary are accessed using keys rather than indices.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ox3V0_v-uBzD"
      },
      "outputs": [],
      "source": [
        "# Example of a dictionary\n",
        "\n",
        "# Creating a dictionary to represent information about a person\n",
        "person = {\n",
        "    \"name\": \"John Doe\",\n",
        "    \"age\": 30,\n",
        "    \"city\": \"New Orleans\",\n",
        "    \"email\": \"john.doe@example.com\"\n",
        "}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j8WfCkBOmO5a"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Accessing elements of the dictionary\n",
        "print(f\"Name:\", person[\"name\"])\n",
        "print(\"Age:\", person[\"age\"])\n",
        "print(\"City:\", person[\"city\"])\n",
        "print(\"Email:\", person[\"email\"])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PUZGUW2omRUi"
      },
      "outputs": [],
      "source": [
        "# Modifying elements of the dictionary\n",
        "person[\"age\"] = 35\n",
        "person[\"city\"] = \"San Francisco\"\n",
        "print(person)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "__u82_i7y7wp"
      },
      "outputs": [],
      "source": [
        "# Adding a new key-value pair to the dictionary\n",
        "person[\"phone\"] = \"123-456-7890\"\n",
        "print(person)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Deleting a key-value pair from the dictionary\n",
        "del person[\"email\"]\n",
        "print(person)"
      ],
      "metadata": {
        "id": "EPrJ012TBzGh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gjLjWGedmq7j"
      },
      "outputs": [],
      "source": [
        "# Iterating over keys of the dictionary\n",
        "print(\"Keys:\")\n",
        "for key in person.keys():\n",
        "    print(key)\n",
        "\n",
        "# Alternativly we dont need to specify .keys()\n",
        "print(\"\\nKeys:\")\n",
        "for key in person:\n",
        "    print(key)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XwtlNWOWms8L"
      },
      "outputs": [],
      "source": [
        "# Iterating over values of the dictionary\n",
        "print(\"Values:\")\n",
        "for value in person.values():\n",
        "    print(value)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "69x4IfhKmuLk"
      },
      "outputs": [],
      "source": [
        "# Iterating over key-value pairs of the dictionary\n",
        "print(\"Key-Value Pairs:\")\n",
        "for key, value in person.items():\n",
        "    print(key, \":\", value)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y6-KM75FoWW_"
      },
      "source": [
        "## Control Flows\n",
        "\n",
        "\n",
        "Control flow refers to the order in which the individual statements and instructions in a program are executed. In Python, control flow is managed through conditional statements (`if`, `elif`, `else`) and loops (`for`, `while`).\n",
        "\n",
        "**Conditional Statements:**\n",
        "\n",
        "\n",
        "* `if`: Executes a block of code if a specified condition is true.\n",
        "* `elif`: Stands for \"else if\". Allows you to check multiple conditions after the initial \"if\" statement.\n",
        "* `else`: Executes a block of code if none of the preceding conditions are true.\n",
        "\n",
        "**Loops:**\n",
        "\n",
        "* `for` Iterates over a sequence (such as a list or range) and executes a block of code for each item in the sequence.\n",
        "* `while`: Executes a block of code repeatedly as long as a specified condition is true. The loop terminates when the condition becomes false.\n",
        "\n",
        "**Control Flow Keywords:**\n",
        "\n",
        "* `break`: Exits the loop prematurely, skipping the remaining iterations.\n",
        "* `continue`: Skips the current iteration of a loop and proceeds to the next iteration.\n",
        "* `pass`: Acts as a placeholder and does nothing when executed. Used to avoid syntax errors in empty code blocks.\n",
        "\n",
        "\n",
        "Control flow allows you to make decisions and repeat actions based on conditions, enabling your programs to respond dynamically to different scenarios and inputs. Understanding and mastering control flow is essential for writing flexible and efficient Python code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M2miIz9_o0o3"
      },
      "outputs": [],
      "source": [
        "# Control flow example\n",
        "\n",
        "# Conditional statement (if-elif-else)\n",
        "num = 10\n",
        "if num > 0:\n",
        "    print(\"Number is positive\")\n",
        "elif num == 0:\n",
        "    print(\"Number is zero\")\n",
        "else:\n",
        "    print(\"Number is negative\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q2kD9E6apusc"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Loop example (for loop)\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "print(\"Fruits:\")\n",
        "for fruit in fruits:\n",
        "    print(fruit)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hOQh4MCFpxzX"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Loop example (while loop)\n",
        "count = 1\n",
        "print(\"Counting from 1 to 5:\")\n",
        "while count <= 5:\n",
        "    print(count)\n",
        "    count += 1 # This is equivalant to as count = count + 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z0HB_fq7pw3B"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Control flow keywords (break and continue)\n",
        "print(\"Skipping even numbers and stopping at 7:\")\n",
        "for i in range(1, 11):\n",
        "    if i % 2 == 0:\n",
        "        continue  # Skip even numbers\n",
        "    elif i == 7:\n",
        "        print(i)\n",
        "        break  # Stop at 7\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AL1tAq0aGQ8E"
      },
      "source": [
        "*Note. A `range` object is distinct from a `list` object. A range object represents an immutable sequence of numbers generated dynamically based on start, stop, and step parameters. Consequently, range objects are memory-efficient because they only store the start, stop, and step parameters, rather than the entire sequence of numbers. You can iterate over a range object using a for loop or convert it to a list or tuple if you need to access all the elements.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "09WrEn9MG68L"
      },
      "outputs": [],
      "source": [
        "# Create a range object\n",
        "my_range = range(1, 10, 2)\n",
        "print(my_range)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# It is common place to iterate over the range object\n",
        "for num in my_range:\n",
        "    print(num)"
      ],
      "metadata": {
        "id": "Z1SZZC-ZC5eD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Observe that `range(1,10,2)` excludes $10$. We can think of range taking values in the clopen interval. That is, `range(a,b)` takes values $[a,b)$."
      ],
      "metadata": {
        "id": "YST61sTLGTdB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert the range object to a list\n",
        "list_range = list(my_range)\n",
        "print(list_range)\n"
      ],
      "metadata": {
        "id": "d1KGl8yPCppm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sx82h13aQD4c"
      },
      "source": [
        "#### List comprehension\n",
        "\n",
        "List comprehension in Python is a concise way to create lists. It allows you to generate a new list by applying an expression to each item in an existing iterable (like a list or range), optionally filtering items with a condition. They have the form\n",
        "\n",
        "```python\n",
        "[expression for item in iterable if condition]\n",
        "```\n",
        "* expression: The value or computation you want to include in the new list.\n",
        "* item: The current item from the iterable.\n",
        "* iterable: The collection of items you're iterating over.\n",
        "* condition (optional): A filter that decides which items to include in the new list.\n",
        "\n",
        "List comprehension provides concise code equivalent to the following:\n",
        "```python\n",
        "my_list =[]\n",
        "for item in iterable:\n",
        "  if condition:\n",
        "    my_list.append(expression)\n",
        "```\n",
        "\n",
        "Let's take a look at some examples. First we create a lists of squares of numbers in two ways."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "alnRiThmQnTI"
      },
      "outputs": [],
      "source": [
        "squares = []\n",
        "for x in range(10):\n",
        "  squares.append(x**2)\n",
        "print(squares)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can reduce the above code to one line using list comprehension."
      ],
      "metadata": {
        "id": "O2kYC1-VE6mH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Example list comprehension\n",
        "\n",
        "squares = [x**2 for x in range(10)]\n",
        "print(squares)"
      ],
      "metadata": {
        "id": "2B9DnjmiEyP6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gkPndby2RIc3"
      },
      "source": [
        "**Exercise:**\n",
        "Using list comprehension construct a list of the even numbers up to 10 (and including)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m_evXpALQ-XN"
      },
      "outputs": [],
      "source": [
        "# Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "even_numbers = [ x for x in range(11) if x%2==0]\n",
        "print(even_numbers)\n"
      ],
      "metadata": {
        "id": "7252g8yOF4j0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G94Qjx_Nqdpb"
      },
      "source": [
        "## Putting it all together: Functions\n",
        "Functions in programming are blocks of code that perform a specific task or computation. They are used to *organize code into reusable modules*, making it easier to manage and maintain."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "63sxlUWFqe-h"
      },
      "outputs": [],
      "source": [
        "# Example function\n",
        "def mystery(x, y):\n",
        "    return (x + y) * (x + y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KUslFTSlzY2z"
      },
      "source": [
        "**Exercise**: Write a function that computes $n!$\n",
        "Remember that $n!=n(n-1)!$ and $0!=1$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jp5lO_WpzUy8"
      },
      "outputs": [],
      "source": [
        "def factorial(n):\n",
        "  #Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "# Recursive way\n",
        "def factorial(n):\n",
        "  if n==0:\n",
        "    return 1\n",
        "  else:\n",
        "    return n*factorial(n-1)\n",
        "print(factorial(6))\n",
        "\n",
        "# Another way\n",
        "def factorial(n):\n",
        "  if n==0:\n",
        "    return 1\n",
        "  else:\n",
        "    value = 1\n",
        "    for x in range(1,n+1):\n",
        "      value= x*value\n",
        "    return(value)\n",
        "\n",
        "print(factorial(6))"
      ],
      "metadata": {
        "cellView": "form",
        "id": "Ll8Mn9pRGsIa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jJFOKg0NrYHB"
      },
      "source": [
        "**Exercise**:\n",
        "Write a function that computes the $n$th [fibonacci number](https://en.wikipedia.org/wiki/Fibonacci_sequence).\n",
        "$$\n",
        "a_n = a_{n-1} + a_{n-2}\n",
        "$$\n",
        "with $a_0 = 0$ and $a_1=1$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3QJVhlGGrKzp"
      },
      "outputs": [],
      "source": [
        "def fibonacci(n):\n",
        "  # Wite your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "# Recursive way\n",
        "def fibonacci(n):\n",
        "  if n <=1:\n",
        "    return n\n",
        "  else:\n",
        "    return fibonacci(n-1) + fibonacci(n-2)\n",
        "\n",
        "print(fibonacci(6))\n",
        "\n",
        "# Dynamic progamming way\n",
        "def fibonacci(n):\n",
        "  arr = [0,1]\n",
        "  for i in range(2,n+1):\n",
        "    arr.append(arr[i-1]+arr[i-2])\n",
        "  return(arr[n])\n",
        "\n",
        "print(fibonacci(6))\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "sNA980d1KIGl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwJCfWOEsTah"
      },
      "source": [
        "**Exercise**: Write a function that takes in two DNA sequences and computes the [Hamming distance](https://chatgpt.com/c/a401a1e4-67f5-4e49-accd-34e4a1db8ff7) between the two. Recall the Hamming distance is given by the minimum number of substitutions required to change one string into the other."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1LNafJQxsSgN"
      },
      "outputs": [],
      "source": [
        "# Hint: You this zip(,) function is helpful\n",
        "\n",
        "def Hamming(str_1,str_2):\n",
        "  for x,y in zip(str_1,str_2):\n",
        "    # Write your code here\n",
        "    print(x,y)\n",
        "\n",
        "dna_seq1 = \"ATCGATCGATCG\"\n",
        "dna_seq2 = \"ATAGATCGATCG\"\n",
        "\n",
        "Hamming(dna_seq1,dna_seq2)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "def Hamming(str_1,str_2):\n",
        "  diff_count = 0\n",
        "  for x,y in zip(str_1,str_2):\n",
        "    if x != y:\n",
        "      diff_count+=1\n",
        "  return(diff_count)\n",
        "\n",
        "dna_seq1 = \"ATCGATCGATCG\"\n",
        "dna_seq2 = \"ATAGATCGATCG\"\n",
        "\n",
        "Hamming(dna_seq1,dna_seq2)\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "UNK91vCuL4dq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mf5qnmB6ybz2"
      },
      "source": [
        "**Exercise**:\n",
        "\n",
        "You are given a list of words. Write a function `word_indices` that takes a list of words and returns a dictionary where the keys are the words themselves, and the values are lists containing the indices (positions) of occurrences of each word in the list.\n",
        "\n",
        "Input:\n",
        "```python\n",
        "words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\"]\n",
        "```\n",
        "Output:\n",
        "```python\n",
        "{\n",
        "    \"apple\": [0, 2, 5],\n",
        "    \"banana\": [1, 4],\n",
        "    \"orange\": [3]\n",
        "}\n",
        "```\n",
        "\n",
        "*Hint:  This `enumerate(,)` function is helpful. We need to add keys and values to a dictionary as well as update values given a key try `.append()`.*\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "caWj4rALrPiA"
      },
      "outputs": [],
      "source": [
        "\n",
        "def word_indicies(list_of_words):\n",
        "  indicies = {}\n",
        "  for idx, word in enumerate(list_of_words):\n",
        "    # Write code here\n",
        "    print(idx,word)\n",
        "\n",
        "words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\"]\n",
        "\n",
        "word_indicies(words)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "def word_indicies(list_of_words):\n",
        "  indicies = {}\n",
        "  for idx, word in enumerate(list_of_words):\n",
        "    if word in indicies.keys():\n",
        "      indicies[word].append(idx)\n",
        "    else:\n",
        "      indicies[word] = [idx]\n",
        "  return indicies\n",
        "\n",
        "words = [\"apple\", \"banana\", \"apple\", \"orange\", \"banana\", \"apple\"]\n",
        "\n",
        "word_indicies(words)\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "grTrKNEpMKbo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J74nEoBjTnFu"
      },
      "source": [
        "**Exercise**: Write a function that checks if a number is prime or not.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dbs5AA-lTr5P"
      },
      "outputs": [],
      "source": [
        "def is_prime(n):\n",
        "  # Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "def is_prime(n):\n",
        "  if n<=1:\n",
        "    return True\n",
        "  for x in range(2,n):\n",
        "    if n%x ==0:\n",
        "      return False\n",
        "  return True\n",
        "\n"
      ],
      "metadata": {
        "id": "JM1SNGEBMp00",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UxL2XjdPULEH"
      },
      "source": [
        "Using this function and list comprehension create a function that returns a list of primes up to `n`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3TfhwxhTUk_v"
      },
      "outputs": [],
      "source": [
        "# Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "def primes(n):\n",
        "  return [ x for x in range(n+1) if is_prime(x)]\n",
        "\n",
        "print(primes(15))\n"
      ],
      "metadata": {
        "cellView": "form",
        "id": "rfY5HSDENs3q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kj4Yb70jpZj2"
      },
      "source": [
        "## Classes\n",
        "\n",
        "A class in Python is a blueprint for creating objects with similar properties and behaviors. Think, *custom data structure.* It serves as a template that defines the structure and behavior of objects, including attributes (data) and methods (functions). Objects created from a class are instances of that class and possess the attributes and behaviors defined by the class.\n",
        "\n",
        "Let's create a class that represents complex numbers.\n",
        "\n",
        "*Note: [cmath](https://docs.python.org/3/library/cmath.html) already exists as a package mathematical functions for complex numbers.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iqL-m5lPpnE8"
      },
      "outputs": [],
      "source": [
        "import math\n",
        "\n",
        "class ComplexNumber:\n",
        "    def __init__(self, real, imag):\n",
        "        self.real = real\n",
        "        self.imag = imag\n",
        "\n",
        "    def __add__(self, other):\n",
        "        return ComplexNumber(self.real + other.real, self.imag + other.imag)\n",
        "\n",
        "    def __sub__(self, other):\n",
        "        return ComplexNumber(self.real - other.real, self.imag - other.imag)\n",
        "\n",
        "    def __mul__(self, other):\n",
        "        real_part = self.real * other.real - self.imag * other.imag\n",
        "        imag_part = self.real * other.imag + self.imag * other.real\n",
        "        return ComplexNumber(real_part, imag_part)\n",
        "\n",
        "    def __truediv__(self, other):\n",
        "        denom = other.real**2 + other.imag**2\n",
        "        real_part = (self.real * other.real + self.imag * other.imag) / denom\n",
        "        imag_part = (self.imag * other.real - self.real * other.imag) / denom\n",
        "        return ComplexNumber(real_part, imag_part)\n",
        "\n",
        "    def norm(self):\n",
        "        return math.sqrt(self.real**2 + self.imag**2)\n",
        "\n",
        "    def __str__(self):\n",
        "        if self.imag >= 0:\n",
        "            return f\"{self.real} + {self.imag}i\"\n",
        "        else:\n",
        "            return f\"{self.real} - {abs(self.imag)}i\"\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VV5VROInpoTB"
      },
      "source": [
        "* Class Definition: We define a class named ComplexNumber to represent complex numbers with real and imaginary parts.\n",
        "* Initializer: The `__init__ `method initializes the real and imaginary parts of the complex number.\n",
        "* Operator Overloading: We define methods `__add__`, `__sub__`, `__mul__`, and `__truediv__` to overload the `+`, `-`, `*`, and `/` operators for complex number arithmetic.\n",
        "* `norm` method that calculates the norm (magnitude) of the complex number using the Euclidean distance formula.\n",
        "* String Representation: The `__str__` method provides a human-readable string representation of the complex number.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eDHtjJ8Qp1bO"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Create instances of ComplexNumber\n",
        "c1 = ComplexNumber(3, 2)\n",
        "c2 = ComplexNumber(1, 7)\n",
        "\n",
        "print(\"c1:\", c1)\n",
        "print(\"c2:\", c2)\n",
        "print(\"Norm of c1:\", norm_c1)\n",
        "print(\"Norm of c2:\", norm_c2)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3WaaMsO1p6Ck"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Perform operations\n",
        "sum_result = c1 + c2\n",
        "diff_result = c1 - c2\n",
        "product_result = c1 * c2\n",
        "quotient_result = c1 / c2\n",
        "\n",
        "# Print results\n",
        "print(\"Sum:\", sum_result)\n",
        "print(\"Difference:\", diff_result)\n",
        "print(\"Product:\", product_result)\n",
        "print(\"Quotient:\", quotient_result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ee5F-9WO0i_L"
      },
      "source": [
        "## Packages\n",
        "\n",
        "One of the main benefits of python is the rich eco-system of open source content. Importing packages in Python is allows you to extend the functionality of your programs by using code written by others and empowers you to build sophisticated, feature-rich applications quickly and efficiently by leveraging existing code, specialized functionality, and the collective expertise of the Python community. It's a fundamental aspect of Python programming that enables you to achieve more with less effort. Many packages provide specialized functionality that would be challenging or time-consuming to implement on your own.\n",
        "\n",
        "There are many great python packages out there. To name a few:\n",
        "* [`numpy`](https://numpy.org/doc/stable/) -  is a powerful library for numerical computing in Python, providing support for large, multi-dimensional arrays and matrices, along with a wide range of mathematical functions to operate on these arrays efficiently. (Think matlab)\n",
        "* [`matplotlib`](https://matplotlib.org/stable/users/index) -  is a comprehensive library for creating static, animated, and interactive visualizations, offering a wide variety of plotting functions and customization options to visualize data in various formats and styles. (Again, think matlab. Its called \"*mat* \" plotlib!)\n",
        "* [`sklearn`](https://scikit-learn.org/stable/user_guide.html) - is a versatile machine learning library in Python, offering simple and efficient tools for data mining and data analysis, including classification, regression, clustering, dimensionality reduction, model selection, and preprocessing techniques.\n",
        "* [`pandas`](https://pandas.pydata.org/docs/user_guide/10min.html) - is a powerful data manipulation and analysis library providing high-performance, easy-to-use data structures and functions for working with structured data.\n",
        "* [`tensorflow`](https://www.tensorflow.org/learn) - is an open-source deep learning framework developed by Google, designed for building and training neural networks and other machine learning models efficiently, offering support for both CPU and GPU computation, distributed computing, and production deployment.\n",
        "\n",
        "It's impossible to know everything so your best friend when coding is [google](google.com) (and sometimes an [LLM](https://en.wikipedia.org/wiki/Large_language_model)). However, if you really want to know what is going on (and you should!) **always read the documentation** when using packages.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "esL-GecONQP2"
      },
      "source": [
        "\n",
        "### Numpy\n",
        "\n",
        "Let's jump into using numpy.\n",
        "\n",
        "Run the following code cell to import the `numpy` module."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AxqfTs6O0iop"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJ4CH_b46VMK"
      },
      "source": [
        "#### Vector and matrix operations\n",
        "\n",
        "We can think of the object `np.array` as either vectors and matrices depending the shape.\n",
        "\n",
        "Call `np.array` to create a NumPy array with your own values."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DZKvcGvf6e9h"
      },
      "outputs": [],
      "source": [
        "x = np.array([1,-2])\n",
        "print(\"x= \",x)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can construct row vectors with `.reshape` or define a row vector explicitly using `[[]]`."
      ],
      "metadata": {
        "id": "T7E1he7rIM-f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.reshape(1,2))\n",
        "\n",
        "# Explictly define row vector\n",
        "row_vec = np.array([[1,-2]])\n",
        "print(row_vec)"
      ],
      "metadata": {
        "id": "ry6OBnZezbR2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BmrgK7LlCd4S"
      },
      "source": [
        " With `x = np.array([1,-2])` we can think of $x = \\begin{bmatrix}1 \\\\ -2  \\end{bmatrix} \\in \\mathbb{R}^2$. We can check the dimension with `x.shape`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xOPCP3WvCcgd"
      },
      "outputs": [],
      "source": [
        "print(f\"Dimension: {x.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ACxjbwU5CzrD"
      },
      "source": [
        "We can also create matrices by passing a list of lists into `np.array()`.\n",
        "For example, with\n",
        "`A = np.array([[a,b],[c,d]])` we can think of $A = \\begin{bmatrix}a&b \\\\ c&d  \\end{bmatrix} \\in \\mathbb{R}^{2\\times 2}$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lytEv-7iCHeo"
      },
      "outputs": [],
      "source": [
        "A = np.array([[1, 1], [0, 1]])\n",
        "print(\"A=\\n\",A)\n",
        "print(f\"Dimension: {A.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j0ZCnyXgD3V2"
      },
      "source": [
        "We can compute $Ax=b\\in\\mathbb{R}^2$ using `np.matmul(A,x)` or `A.dot(x)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nL2ZE6b3D2BD"
      },
      "outputs": [],
      "source": [
        "b=np.matmul(A,x)\n",
        "print(\"b = \",b)\n",
        "print(f\"Dimension: {b.shape}\")\n",
        "# np.matmul(A,x) == A.dot(x) # Check equivalence"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0d2hT4eQhBAX"
      },
      "source": [
        "Given $A\\in \\mathbb{R}^{2\\times 2}$ and $b\\in \\mathbb{R}^2$ we can solve $Ax=b$ using `np.linalg.solve(A,b)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "suE_mDTmhPPP"
      },
      "outputs": [],
      "source": [
        "A = np.array([[1, 2], [3, 5]])\n",
        "b = np.array([1, 2])\n",
        "x = np.linalg.solve(A, b)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hIEtPpeky3d7"
      },
      "source": [
        "Compute eigenvalues and eigenvectors of a matrix `A` using `np.linalg.eig(A)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VvkF1yhVzF2A"
      },
      "outputs": [],
      "source": [
        "A = np.array([[1, 0], [0, -2]])\n",
        "eigen_info = np.linalg.eig(A)\n",
        "\n",
        "# Check what type np.linalg.eig returns\n",
        "#print(type(eigen_info))\n",
        "\n",
        "values = eigen_info.eigenvalues\n",
        "vectors =  eigen_info.eigenvectors\n",
        "\n",
        "\n",
        "print(\"First eigenvalue:\", values[0])\n",
        "\n",
        "print(\"First eigenvector:\", vectors[0])\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nAgbziBGMcXu"
      },
      "source": [
        "We can compute the matrix product $AB$ with `np.matmul(A,B)` or `A.dot(B)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xZPDJ6oKMjIJ"
      },
      "outputs": [],
      "source": [
        "# Example matrix multiplication\n",
        "A = np.array([[1, 1], [0, 1]])\n",
        "\n",
        "B = np.array([[0,1],[1,0]])\n",
        "\n",
        "AB = np.matmul(A,B)\n",
        "\n",
        "print(\"AB = \\n\", AB)\n",
        "\n",
        "#print(AB==A.dot(B)) # Check if it is equivallent"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h1bg28kBJHXs"
      },
      "source": [
        "We can obtain $A^\\top$ with  `A.transpose`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2GTjDrXCJpL9"
      },
      "outputs": [],
      "source": [
        "print(A.transpose())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H9Rik1wTJ60_"
      },
      "source": [
        "We can add two vectors of the same size with (`+`), and we can also scale vectors with `*`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wZ2dBWjxKKlg"
      },
      "outputs": [],
      "source": [
        "x = np.array([1,2,-1,3])\n",
        "y = np.array([1,0,3,-2])\n",
        "\n",
        "#Add two vectors\n",
        "vector_sum = x + y\n",
        "print(\"x+y=\", vector_sum)\n",
        "\n",
        "#Scale vector\n",
        "scaled_vector= 2*x\n",
        "print(\"2*x=\",scaled_vector)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J3U9YaZBK0rv"
      },
      "source": [
        "*Note. The* (`*`) *and (`+`) operators in numpy preforms an type of operation called [broadcasting](https://developers.google.com/machine-learning/glossary/#broadcasting). You can simply think of broadcasting as an entry wise operation between two different arrays of some compatable dimension. Broadcasting enables operation by virtually expanding the vector of length and replicating the same values down each column.* For example."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tflGgdOsKlH4"
      },
      "outputs": [],
      "source": [
        "A = np.array([[0,0,0,0],[1,1,1,1]])\n",
        "x = np.array([1,2,-1,3])\n",
        "\n",
        "print(\"A+2=\\n\",A + 2)\n",
        "print(\"A+x=\\n\",A+x)\n",
        "print(\"A*x=\\n\",A*x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AGUz3ef3E3QP"
      },
      "source": [
        "#### Populating generic and random arrays\n",
        "\n",
        "To populate an array with all zero, call `np.zeros`. To populate an array with all ones, call `np.ones`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LkZAAExPE2ID"
      },
      "outputs": [],
      "source": [
        "zeros = np.zeros(5)\n",
        "print(zeros)\n",
        "\n",
        "ones = np.ones(5)\n",
        "print(ones)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aowu2EWIFi4C"
      },
      "source": [
        "To populate an array as a sequence of numbers from `a` to `b` (excluding `b`), call `np.arange(a,b)`. This is just like range in vanila python, but with numpy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "R25EZiCOFoT0"
      },
      "outputs": [],
      "source": [
        "sequence = np.arange(3,10,2)\n",
        "print(sequence)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DY0eJAwajaYZ"
      },
      "source": [
        "To populate an array with `n` equidistant values ranging from `a` to `b` use `np.linspace(a,b,n)`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YvALQfKajZ7n"
      },
      "outputs": [],
      "source": [
        "sequence = np.linspace(-1,1,10)\n",
        "print(sequence)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2nBczUHNHc0e"
      },
      "source": [
        "We can also populate arrays with random values.\n",
        "\n",
        "Suppose we wanted to generate the random vector $\\mathbf{X}= \\begin{bmatrix}X_1\\\\ \\vdots \\\\ X_{10} \\end{bmatrix}$ where $X_i \\stackrel{i.i.d}\\sim \\text{Unif}[0,1]$. Then we can use `np.random.random(size = (10,))`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0MIz0RN9Hb5z"
      },
      "outputs": [],
      "source": [
        "X = np.random.random(size = (10,))\n",
        "print(X)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vFHUat9mNdbE"
      },
      "source": [
        "**Exercise**:\n",
        "Generate a matrix $A\\in \\mathbb{R}^{2\\times 4}$ where $A_{i,j}\\stackrel{i.i.d}\\sim \\text{Unif}(5,10)$.\n",
        "\n",
        "*Hint: If*  $X\\sim\\text{Unif}(a,b)$, *then* $\\frac{X-a}{b-a}\\sim\\text{Unif}(0,1).$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2xaqEO_4OKqE"
      },
      "outputs": [],
      "source": [
        "# Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "U = np.random.random(size = (2,4))* 5 + 5\n",
        "print(U)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "p2o3t66lObJn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8e-hd1wv0ol"
      },
      "source": [
        "#### Slicing Arrays\n",
        "\n",
        "Slicing multidimensional NumPy arrays allows you to access specific elements or ranges along different axes of the array.\n",
        "\n",
        "*For more information no slicing ndarrays check [here](https://numpy.org/doc/stable/user/basics.indexing.html).*\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3d6Y794AwRnZ"
      },
      "outputs": [],
      "source": [
        "arr = np.array([[1, 2, 3],\n",
        "                [4, 5, 6],\n",
        "                [7, 8, 9]])\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zaVAhF_Kxf0Q"
      },
      "outputs": [],
      "source": [
        "element = arr[1,1]\n",
        "print(element)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gv4miITdwgKO"
      },
      "outputs": [],
      "source": [
        "# Select the first row\n",
        "row_1 = arr[0]\n",
        "print(row_1.shape)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1fJ4LEj_wiFR"
      },
      "outputs": [],
      "source": [
        "# Select the second column\n",
        "col_2 = arr[:, 1]\n",
        "print(col_2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PHiN6-_UwjDk"
      },
      "outputs": [],
      "source": [
        "# Select a subarray\n",
        "sub_arr = arr[0:2, 0:2]\n",
        "print(sub_arr)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAy_6SXAws76"
      },
      "source": [
        "We can also pass a boolean mask to select elements."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tes79pzhww-a"
      },
      "outputs": [],
      "source": [
        "# Select elements greater than 5\n",
        "bool_idx = arr > 5\n",
        "print(bool_idx)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yxqmLYj8w2DA"
      },
      "outputs": [],
      "source": [
        "# Use boolean indexing to get the values greater than 5\n",
        "values = arr[bool_idx]\n",
        "print(values)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjHYVBeGytH1"
      },
      "source": [
        "**Exercise:**\n",
        "\n",
        "You are given a square 2D NumPy array arr of size $n x n$, representing a matrix of integers. Your task is to implement a function `diagonal_difference(arr)` that calculates the absolute difference between the diagonal sums.\n",
        "\n",
        "e.g\n",
        "\n",
        "input:\n",
        "```python\n",
        "arr = np.array([[11, 2, 4],\n",
        "                [4, 5, 6],\n",
        "                [10, 8, -12]])\n",
        "```\n",
        "output:\n",
        "```python\n",
        "15\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-eF74IfL0KnY"
      },
      "outputs": [],
      "source": [
        "def diagonal_difference(arr):\n",
        "  # Write your code here\n",
        "  return abs_diff"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7INZPHKP0USx"
      },
      "outputs": [],
      "source": [
        "# Test the function\n",
        "arr = np.array([[11, 2, 4],\n",
        "                [4, 5, 6],\n",
        "                [10, 8, -12]])\n",
        "\n",
        "result = diagonal_difference(arr)\n",
        "print(result)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "def diagonal_difference(arr):\n",
        "  n = len(arr)\n",
        "  main_diag = []\n",
        "  anti_diag = []\n",
        "  n= len(arr)\n",
        "  for i in range(n):\n",
        "    main_diag.append(arr[i,i])\n",
        "    anti_diag.append(arr[i,n-i-1])\n",
        "  main_sum = np.sum(main_diag)\n",
        "  anti_sum = np.sum(anti_diag)\n",
        "  abs_diff = abs(main_sum-anti_sum)\n",
        "\n",
        "# Another way with list comprehension\n",
        "def diagonal_difference(arr):\n",
        "  n = len(arr)\n",
        "  diag_1 = np.sum([ arr[i,i] for i in range(n)])\n",
        "  diag_2 = np.sum([ arr[i,n-i-1] for i in range(n)])\n",
        "  abs_diff= abs(diag_1-diag_2)\n",
        "  return abs_diff\n",
        "\n",
        "arr = np.array([[11, 2, 4],\n",
        "                [4, 5, 6],\n",
        "                [10, 8, -12]])\n",
        "\n",
        "result = diagonal_difference(arr)\n",
        "print(result)"
      ],
      "metadata": {
        "id": "sI_DhZIuRBjH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JXtr5-GNOJ8s"
      },
      "source": [
        "### Matplotlib\n",
        "\n",
        "Let's jump into using Matplotlib. We will use [Pyplot](https://matplotlib.org/stable/tutorials/pyplot.html) which effectivly makes matplotlib work like MATLAB.\n",
        "\n",
        "Run the following code cell to import the `matplotlib.pyplot` module."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1MuBVUKM54-b"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WxmT4Ld6lQQU"
      },
      "source": [
        "Lets plot a simple histogram of samples drawn from a normal distribution with mean $3$ and variance $2$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rY4VbNCmlPf3"
      },
      "outputs": [],
      "source": [
        "#Generate a sample\n",
        "sample = np.random.normal(loc = 3,scale = np.sqrt(2),size=100)\n",
        "print(sample)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jgDltfsvmIpS"
      },
      "outputs": [],
      "source": [
        "plt.hist(sample,density=True)\n",
        "plt.title('My Sample')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__vJXASGmr8_"
      },
      "source": [
        "We can now overlay the density function of the normal distribution with mean $\\mu$ and variance $\\sigma^2$ given by\n",
        "$$\n",
        "f(x) = \\frac{1}{\\sqrt{2\\pi}\\sigma}e^{-\\frac{(x-\\mu)^2}{2\\sigma^2}}\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uFlRknLDzO9g"
      },
      "outputs": [],
      "source": [
        "# Generate data to evaluate the density\n",
        "import numpy as np\n",
        "X = np.linspace(-5, 10, 1000)\n",
        "\n",
        "# Define density function\n",
        "def normal_density(x,sigma,mu):\n",
        "   return np.exp(-(x-mu)**2/(2*sigma**2))/(np.sqrt(2*np.pi)*sigma)\n",
        "\n",
        "y = normal_density(X,np.sqrt(2),3)\n",
        "# Equivalently y = np.array([normal_density(x,np.sqrt(2),3) for x in X ])\n",
        "\n",
        "# Plot the density function\n",
        "plt.plot(X, y,color = 'orange', label=\"Normal distribution\")\n",
        "\n",
        "# Plot the histogram of samples\n",
        "plt.hist(sample,density=True, label=\"Samples\")\n",
        "\n",
        "# Add labels and legend\n",
        "plt.xlabel(\"x\")\n",
        "plt.ylabel(\"Density\")\n",
        "plt.legend()\n",
        "\n",
        "# Show the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Qh8gh4rZAiQd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-8MGuGoLpuYw"
      },
      "source": [
        "**Exercise**\n",
        "\n",
        "Plot the eigenvalues of a large (500 dimensional) Wigner matrix and add the density of the semi-circle distribution. *For more information see Anderson, et. al. An introduction to random matrices, Cambridge University Press, page 6.*\n",
        "\n",
        "*Hint: Use `np.linalg.eig` and `plt.hist`*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aOydPcO-jImm"
      },
      "outputs": [],
      "source": [
        "# Use this to plot the semi-cicle density\n",
        "x = np.linspace(-2,2,1000)\n",
        "y = np.sqrt(4-x**2)/2/np.pi\n",
        "\n",
        "n=500\n",
        "A = np.random.randn(n,n)\n",
        "W = 1/np.sqrt(n)*((1/np.sqrt(2))*(A+A.T) +(1- np.sqrt(2))*np.diag(np.diag(A)))\n",
        "\n",
        "# Write your code here"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "\n",
        "x = np.linspace(-2,2,1000)\n",
        "y = np.sqrt(4-x**2)/2/np.pi\n",
        "\n",
        "\n",
        "n=500\n",
        "\n",
        "A = np.random.randn(n,n)\n",
        "W = 1/np.sqrt(n)*((1/np.sqrt(2))*(A+A.T) - (1- np.sqrt(2))*np.diag(np.diag(A)))\n",
        "\n",
        "eigen_vals = np.linalg.eigvals(W)\n",
        "\n",
        "plt.hist(eigen_vals,30, range=[-2.5, 2.5],density=True)\n",
        "plt.plot(x,y)\n",
        "plt.show()"
      ],
      "metadata": {
        "cellView": "form",
        "id": "2gpsXvH5UM1I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ingKeT8nuYO-"
      },
      "source": [
        "### Scikit learn\n",
        "\n",
        "Scikit learn has many a plethora of machine learning and statistics functionality. The process simply consists of constructing a model and applying a fit function. Lets look at a few examples.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhhTH3ukCYXt"
      },
      "source": [
        "\n",
        "#### Linear Regression\n",
        "\n",
        "Given observations $X_i$ and $Y_i$ where\n",
        "$$\n",
        "Y_i = X_i\\beta_1 + \\beta_0 + ɛ_i\n",
        "$$\n",
        "\n",
        "where $ɛ_i$ are independent mean zero normal random varaibles. We like to estimate $\\beta_1$ and $\\beta_0$. This is done by computing the $\\beta_1$ and $\\beta_0$ which minimize sum of squared errors,\n",
        "$$\n",
        "SSE:=\\sum \\big(Y_i - (X_i\\beta_1 + \\beta_0)\\big)^2.\n",
        "$$\n",
        "\n",
        "(for more info on [linear regression](https://en.wikipedia.org/wiki/Linear_regression))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Hp-oPNx68wE4"
      },
      "outputs": [],
      "source": [
        "# Generate some random data\n",
        "X = np.linspace(0,10,100)\n",
        "y = 2 * X + 3 + np.random.randn(100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_hf7KB2QuXt0"
      },
      "outputs": [],
      "source": [
        "from sklearn.linear_model import LinearRegression\n",
        "\n",
        "# Create the linear regression model\n",
        "model = LinearRegression()\n",
        "\n",
        "\n",
        "# Fit the model to the data\n",
        "\n",
        "# We need to first properly reshape the data otherwise we get an error.\n",
        "X = X.reshape(-1,1)\n",
        "model.fit(X, y)\n",
        "\n",
        "print(f\"Coef estimate: {model.coef_}\")\n",
        "print(f\"Intercept estimate: {model.intercept_}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wt5fNKM8_xnC"
      },
      "source": [
        "**Exercise:** Use `matplotlib` to plot the synthetic data `X` and `y` and the regression line.\n",
        "\n",
        "*Hint: try `plt.scatter` and `plt.plot`*"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Write your code here"
      ],
      "metadata": {
        "id": "tHYK-hCJbwks"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AbRa5cCA-aUP"
      },
      "outputs": [],
      "source": [
        "# @title Solution\n",
        "\n",
        "y_predict = X*model.coef_[0] + model.intercept_\n",
        "plt.scatter(X,y)\n",
        "plt.plot(X,y_predict,color=\"orange\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35c3hI-KNjCe"
      },
      "source": [
        "#### k-means\n",
        "k-means is a simple and popular algorithm for clustering convex data sets.\n",
        "The algorithm is an interative processes and is as follows:\n",
        "```\n",
        "input: k, data, max_num_of_iterations\n",
        "c_1,...,c_k = k randomly chosen data points\n",
        "i = 0\n",
        "while i <= max_num_of_iterations:\n",
        "  C_1,...,C_k = data points closest to c_1,...,c_k\n",
        "  c_1,...,c_k = mean(C_1),...,mean(C_k)\n",
        "  i = i+1\n",
        "return  C_1,...,C_k, c_1,...,c_k\n",
        "```\n",
        "\n",
        " First lets simulate and plot some synthetic data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HcO3uG0zwGye"
      },
      "outputs": [],
      "source": [
        "# Generate synthetic data\n",
        "X_1 = np.random.multivariate_normal([-1, 2], [[1, 0.5], [0.5, 1]], size=200)\n",
        "X_2 = np.random.multivariate_normal([2, -1], [[1, 0.5], [0.5, 1]], size=200)\n",
        "data = np.concatenate((X_1,X_2))\n",
        "\n",
        "# Plot data\n",
        "plt.scatter(data[:, 0], data[:, 1])\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AvjfDqLRAz0x"
      },
      "source": [
        "Let's now use sklearn and apply k-means to cluster this data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UyJM2KiwvoAC"
      },
      "outputs": [],
      "source": [
        "# Apply k-means clustering\n",
        "from sklearn.cluster import KMeans\n",
        "\n",
        "# Create the k-means Model\n",
        "kmeans = KMeans(n_clusters=2,n_init = 'auto')\n",
        "\n",
        "# Fit the Model\n",
        "kmeans.fit(data)\n",
        "\n",
        "# Look at the clusters obtained\n",
        "print(kmeans.cluster_centers_[0])\n",
        "print(kmeans.cluster_centers_[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wM8URVxAGtQ5"
      },
      "source": [
        "Let's plot the obtained clusters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hSA4bNl7wjXO"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Plot the data points\n",
        "plt.scatter(data[:, 0], data[:, 1], c=kmeans.labels_)\n",
        "\n",
        "# Plot the cluster centers\n",
        "plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], marker='x', color='red')\n",
        "\n",
        "# Add labels and title\n",
        "plt.xlabel(\"X_1\")\n",
        "plt.ylabel(\"X_2\")\n",
        "plt.title(\"Scatter plot of X_1 and X_2 with cluster labels\")\n",
        "\n",
        "# Show the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6x_yNOEuIviw"
      },
      "source": [
        "**Exercise:** Using the previous data lets try and implement k-means from scratch using only `numpy`.\n",
        "\n",
        "*Hint: `np.argmin` may be useful.*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RP3HQ05JJXse"
      },
      "outputs": [],
      "source": [
        "def k_means(k,data,max_iterations=10):\n",
        "  # Pick k centers and place them in a list\n",
        "  centroid = data[np.random.choice(range(len(data)),k),:]\n",
        "  i = 0\n",
        "  while i<= max_iterations:\n",
        "    # Write some below\n",
        "    cluster = []\n",
        "    centroid = []\n",
        "    i+=1\n",
        "\n",
        "  return centroid\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Solution\n",
        "def k_means(k,data,max_iterations=10):\n",
        "  # Pick k centers and place them in a list\n",
        "  centroid = data[np.random.choice(range(len(data)),k),:]\n",
        "  i = 0\n",
        "  while i<= max_iterations:\n",
        "    # Construct a list that keeps track of the clostest centroid to each point\n",
        "    closest = []\n",
        "    for point in data:\n",
        "      distances = [np.sum((center - point)**2) for center in centroid]\n",
        "      closest_centroid = np.argmin(distances)\n",
        "      closest.append(closest_centroid)\n",
        "    closest=np.array(closest)\n",
        "    # Compute new centroids based on the closest\n",
        "    for j in range(k):\n",
        "      new_centroid = np.mean(data[closest==j ],axis=0)\n",
        "      centroid[j] = new_centroid\n",
        "    i+=1\n",
        "  return centroid\n",
        "\n",
        "\n",
        "\n",
        "# More compactly Using list comprehension\n",
        "\n",
        "def k_means(k,data,max_iterations=10):\n",
        "  centroid = data[np.random.choice(range(len(data)),k),:]\n",
        "  i = 0\n",
        "  while i<= max_iterations:\n",
        "    closest = np.array([np.argmin([np.sum((center - point)**2) for center in centroid]) for point in data])\n",
        "    centroid = np.array([ np.mean(data[closest==j ],axis=0) for j in range(k)])\n",
        "    i+=1\n",
        "  return centroid\n",
        "\n",
        "k_means(2,data,max_iterations=15)"
      ],
      "metadata": {
        "cellView": "form",
        "id": "YkQL8D4Wks83"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HYK_OEq4q_tF"
      },
      "source": [
        "### Keras/Tensorflow\n",
        "\n",
        "[TensorFlow](https://www.tensorflow.org/) is an open-source machine learning framework developed by Google. It's one of the most popular tools for building and deploying machine learning models, particularly deep learning models. TensorFlow provides a comprehensive ecosystem of tools, libraries, and community resources that make it easier for developers and researchers to create and deploy machine learning applications. [Keras](https://keras.io/) is a high-level neural networks API (Application Programming Interface) seamlessly integrated into TensorFlow (Jax and Pytorch), allowing users to access Keras's high-level API while leveraging TensorFlow's scalability, performance, and ecosystem.\n",
        "\n",
        "Let's build a simple neural network that classifies hand written digits."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "h37oTIgVrw8u"
      },
      "outputs": [],
      "source": [
        "# Import mnist hand written data from keras data set\n",
        "# Load data as test train split\n",
        "\n",
        "from tensorflow.keras.datasets import mnist\n",
        "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
        "\n",
        "# Size of training images\n",
        "print(train_images.shape)\n",
        "\n",
        "# Size of training labels\n",
        "print(train_labels.shape)\n",
        "\n",
        "# Size of training images\n",
        "print(test_images.shape)\n",
        "\n",
        "# Size of training labels\n",
        "print(test_labels.shape)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mLFv6dtWsY-l"
      },
      "outputs": [],
      "source": [
        "# Lets look at the data\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "digit = train_images[4]\n",
        "print(f'Image shape: {digit.shape}')\n",
        "\n",
        "plt.imshow(digit, cmap=plt.cm.binary)\n",
        "plt.show()\n",
        "print(f' Label: {train_labels[4]}')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Building a model requires 3 things minimum.\n",
        "1. **Optimizer** - Mechanism through which the model will update itself based on the training data\n",
        "2. **Loss function** - measures performance as feedback to optimizer\n",
        "3. **Metrics** - Monitor performace during training and testing\n",
        "      * Classification accuracy = fraction of images correctly classified\n"
      ],
      "metadata": {
        "id": "k2Fdd_mhrAGj"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BCKH-Anur8KO"
      },
      "outputs": [],
      "source": [
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "\n",
        "# Define Model\n",
        "# Two dense layers\n",
        "model = keras.Sequential([layers.Dense(512,activation=\"relu\"),layers.Dense(10,activation=\"softmax\")])"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(optimizer=\"rmsprop\",\n",
        "    loss=\"sparse_categorical_crossentropy\",\n",
        "    metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "skGSIbAvqArK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_images = train_images.reshape((60000, 28 * 28)) #Flatting 2 dim image data to vector\n",
        "train_images = train_images.astype(\"float32\") / 255 # Rescale values between [0,1]\n",
        "test_images = test_images.reshape((10000, 28 * 28))\n",
        "test_images = test_images.astype(\"float32\") / 255"
      ],
      "metadata": {
        "id": "R14-cw9iqEGT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(train_images, train_labels, epochs=5, batch_size=128)\n",
        "# Store accuracy and loss while training\n",
        "acc = history.history['accuracy']\n",
        "loss = history.history['loss']"
      ],
      "metadata": {
        "id": "XGQxoSIhqGqT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lets plot the accuracy and loss during training to get a sense of what happened."
      ],
      "metadata": {
        "id": "ZbWjYtbrRpbs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = range(1, len(acc) + 1)\n",
        "\n",
        "# Plotting training accuracy\n",
        "plt.plot(epochs, acc, 'b', label='Training accuracy')\n",
        "plt.title('Training accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "eDJm7iP9Rgcq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Plotting training and validation loss\n",
        "plt.plot(epochs, loss, 'b', label='Training loss')\n",
        "plt.title('Training loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "VCdJmztkUPvq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Test on the first 10 images of the testing set"
      ],
      "metadata": {
        "id": "lls7aWXAOs7X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_digits = test_images[0:10] # Select first 10 images\n",
        "predictions = model.predict(test_digits) # Make prediction"
      ],
      "metadata": {
        "id": "FQtSwjQ1qufR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# See prediction of first\n",
        "print(predictions[0]) #See predicited probability of image being in one class\n",
        "prediction = predictions[0].argmax()\n",
        "print(prediction)\n",
        "print(predictions[0][7]) #Probability of sample coming from the class 7"
      ],
      "metadata": {
        "id": "hIPCiI3uO2SJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Evaluate the model on the test set"
      ],
      "metadata": {
        "id": "s7ig_sR0q6vY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "test_loss, test_acc = model.evaluate(test_images, test_labels)\n",
        "print(f\"test_acc: {test_acc: .2f}\")"
      ],
      "metadata": {
        "id": "2SEfnN-XqzSs"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}