NSIP-itertools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "89bb3a0b-328f-4e05-bfa5-f4dacbef2bcd",
   "metadata": {},
   "source": [
    "# Efficient Looping with Itertools"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feecff5b-08d4-46aa-be4f-edb3367f74b9",
   "metadata": {},
   "source": [
    "Itertools is a module that comes built-in with your Python installations, and contains functions that create iterators for efficient looping."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1bfaebb-61f2-4a03-b24d-5e72978ca334",
   "metadata": {},
   "source": [
    "## Iterators and Iterables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781df36f-b3bf-4a6d-94fb-8bc1be0ee092",
   "metadata": {},
   "source": [
    "**Iterable**<br>\n",
    "- An object capable of returning its members one at a time i.e. anything that can be looped over.\n",
    "- Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects.\n",
    "- You can identify an iterable object by the presence of the \\_\\_iter__ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4406caef-78bd-4497-bb07-d40baefe839e",
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e140bf7c-3101-4522-a03a-35a5b8ef9888",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in nums:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd11c9a1-0493-4b0b-909b-120d1e763d8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75fabde4-ef27-4416-bea8-0c92c040548d",
   "metadata": {},
   "outputs": [],
   "source": [
    "'__iter__' in dir(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28ac6fa-b67f-429f-b003-0bdc57583112",
   "metadata": {},
   "source": [
    "**Iterator**<br>\n",
    "- An object with a state, that remembers what the current state is, and knows how to get the next state or value.\n",
    "- You can identify an iterator by the presence of the \\_\\_next__ method.\n",
    "- You can create an iterator for an iterable by calling the \\_\\_iter__ method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3acd81e-743d-4c38-b1ac-4778873b3287",
   "metadata": {},
   "outputs": [],
   "source": [
    "i_nums = nums.__iter__() # iter(nums) does the same thing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe4bb6af-f01f-46f0-9c2c-c8a9c1e70ebc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(i_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15fb6dda-2fce-4883-b969-46460440e1b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(i_nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb17158-b10c-4cc3-8903-54d02d0c4ec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "'__next__' in dir(i_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0194a8b0-8f8e-4cff-8b31-d85c088a4767",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(i_nums)) # same as: print(i_nums.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33dee8a4-83cc-4c1f-963d-408f5597f513",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(i_nums)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d07088a-fd62-4106-89db-f943c6032323",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(i_nums)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe6dceb0-3804-4ce4-9855-6d4c19058094",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(i_nums)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7a6b8ca-d446-4787-9cd7-34f3426cc429",
   "metadata": {},
   "source": [
    "The `StopIteration` exception tells us that the iterator has run through all the members of the list it was iterating through."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a94023f-ccc0-450e-bc37-03d44ec7e626",
   "metadata": {},
   "source": [
    "**New perspective on for loops**<br>\n",
    "Behind the scenes, a `for` loop creates an iterator, uses the `next()` method to get the next value (or state) of the iterator, until it runs into the StopIteration exception, at which point it breaks out of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e039fbc6-a8b8-4400-93c8-c21024e3183e",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in nums:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd128bee-242b-4632-a131-ab907e625071",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "(a) Is the string 'hello' an iterable? <br>\n",
    "(b) How can you know this using Python code? <br>\n",
    "(c) Create an iterator for 'hello' <br>\n",
    "(d) Is my_set {1, 2, 3} an iterable? Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adccca3f-ec20-4be3-8d04-4df2a165a2f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"hello\"\n",
    "my_set = {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adecbe2e-fee1-4889-a6ef-ab5b07616142",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fa4b504-e307-481c-9863-917413fc40f4",
   "metadata": {},
   "source": [
    "## Itertools functions\n",
    "According to the itertools docs, it is a “module [that] implements a number of iterator building blocks inspired by constructs from APL, Haskell, and SML… Together, they form an ‘iterator algebra’ making it possible to construct specialized tools succinctly and efficiently in pure Python.”\n",
    "\n",
    "Loosely speaking, this means that the functions in itertools “operate” on iterators to produce more complex iterators. Consider, for example, the built-in `zip()` function, which takes any number of iterables as arguments and returns an iterator over tuples of their corresponding elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e147ce2f-b002-4fb3-bb53-2b54243610c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3]\n",
    "letters = ['a', 'b', 'c']\n",
    "\n",
    "zip(numbers, letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3dade76-65f5-4d67-a483-b6de84fa6aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(zip(numbers, letters))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f93682-fb2e-4aed-b8a0-ccd8e40b992e",
   "metadata": {},
   "source": [
    "How, exactly, does `zip()` work?\n",
    "\n",
    "- `[1, 2, 3]` and `['a', 'b', 'c']`, like all lists, are iterable, which means they can return their elements one at a time. <br>\n",
    "- Under the hood, the `zip()` function works, in essence, by calling `iter()` on each of its arguments, then advancing each iterator returned by `iter()` with `next()` and aggregating the results into tuples. The iterator returned by `zip()` iterates over these tuples. <br><br>\n",
    "In other words, iterators themselves are _iterable_, making it possible to do complex looping operations with them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc595846-27b6-4703-afc4-1d01aad12c0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "'__iter__' in dir(i_nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616cc45b-0783-4fa1-95ba-ed5a70600407",
   "metadata": {},
   "source": [
    "**Why should you use iterators?** <br>\n",
    "There are two main reasons why such an “iterator algebra” is useful:\n",
    "- improved memory efficiency (via lazy evaluation)\n",
    "- faster execution time.\n",
    "\n",
    "Essentially when you use an iterator, it only needs to store it's current state in memory, and know how to get the next state or value. \n",
    "Suppose in the `zip` example above, both your lists had a 100 million elements. It would take up a lot of memory to store all these values. However, an iterator only stores one value from each list at a time - saving immensely on memory resources."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08659eda-6116-41a5-886f-07fef3a0586d",
   "metadata": {},
   "source": [
    "Today we will cover some widely-used itertools functions, however there are mamy more that you can check out at https://docs.python.org/3/library/itertools.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdfcf35a-80c9-45b7-a971-bd99bc71e747",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eefeb480-0413-4e52-9ea6-4626ac060924",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(itertools)) # your version might have some newer methods as well"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ecf5a2-cdd7-4c16-b0ca-cf1672a31257",
   "metadata": {},
   "source": [
    "## Types of iterators\n",
    "- Infinite iterators\n",
    "- Finite iterators\n",
    "- Combinatoric iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f19e5eb-733f-4d54-95be-10c88b0f3020",
   "metadata": {},
   "source": [
    "### Infinite iterators\n",
    "Let's start with infinite iterators, the generators that never say \"stop.\" They just keep going and going! In this section, we'll focus on three basic but powerful infinite iterators: `count`, `cycle`, and `repeat`. Each has its own unique utility and can make your data science tasks more efficient."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "920e1df3-b69f-4f07-8d10-1cafc563eb42",
   "metadata": {},
   "source": [
    "#### count()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2616d05c-a3bb-4615-95de-0df46b63f525",
   "metadata": {},
   "source": [
    "`count` creates an infinite iterator that generates consecutive numbers. In data science, this function can be used for adding indexes or time-stamps to a data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8dc5379-e42e-4cee-a520-4d73eb899b54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start counting from 1 , increments by 1 indefinitely\n",
    "counter = itertools.count(start=1)\n",
    "print(next(counter))\n",
    "print(next(counter))\n",
    "print(next(counter))\n",
    "print(next(counter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dacbc79-52d6-48a7-a1bc-30621d18ecc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulated data points for weight measurements\n",
    "weight_data = [70, 71, 69, 68, 70]\n",
    "\n",
    "# Create a dictionary with unique ID numbers for each weight\n",
    "indexed_data = {}\n",
    "for index, weight in zip(counter, weight_data):\n",
    "    indexed_data[index] = weight\n",
    "print(indexed_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "902dcacb-8a96-4268-ae08-2a81488f7605",
   "metadata": {},
   "source": [
    "Why did the indexing start from 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19854600-3d94-4fcf-b4e2-9f825c86df0b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2877cdf3-33cc-40f9-acb4-57d4ca243338",
   "metadata": {},
   "source": [
    "#### cycle()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1265bb55-a4dd-4795-8d46-3938862774c5",
   "metadata": {},
   "source": [
    "`cycle` creates an infinite iterator that loops over an input sequence indefinitely. In data science, this can be useful for tasks that require periodic or cyclical patterns. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ea2d869-6c5a-477e-90c3-1ba1c7584171",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a cycle of days of the week\n",
    "days_of_week = itertools.cycle(['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'])\n",
    "\n",
    "# Simulated temperature data for several days\n",
    "temperatures = [23, 25, 22, 21, 20, 19, 24, 22, 18, 17, 19, 23]\n",
    "\n",
    "# temp-day pairs\n",
    "weather_report = list(zip(days_of_week, temperatures))\n",
    "print(weather_report)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c296265e-09e3-402c-abb1-d7f494637aff",
   "metadata": {},
   "source": [
    "#### repeat()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "498b72b5-7601-429b-88f2-2f062d1e2768",
   "metadata": {},
   "source": [
    "`repeat` creates an iterator that produces a specified value indefinitely or for a given number of times. In data science, repeat() can be useful when you need to fill or extend data with a constant value. Imagine you're tracking monthly sales data and you want to project the same revenue for the next few months as a placeholder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65bb5e70-bd6d-4eb8-bbfa-8e263eea9896",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Existing revenue data for past months\n",
    "past_revenue = [4000, 4200, 4500]\n",
    "\n",
    "# Use repeat to generate the same revenue for the next 3 months\n",
    "revenue_projection = list(itertools.repeat(5000, 3))\n",
    "\n",
    "# Combine past revenue and future projections\n",
    "total_revenue = past_revenue + revenue_projection\n",
    "\n",
    "print(total_revenue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e7e113-1e34-4577-b042-01179786d59d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ca91b607-4de1-4734-83d1-c860e0ac5617",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "You have a new drug treatment you want to test in clinical trials. You have 3 categories of treatment: 'placebo', 'drug_5mg' , 'drug_10mg'. You don't know how many patients will register for this trial but you would like equal numbers of patients in each group. How can you use itertools to assign patients to treatment categories?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c6e73ba-71be-4f0b-9e46-1030c3b03871",
   "metadata": {},
   "outputs": [],
   "source": [
    "treament_categories = [ 'placebo', 'drug_5mg' , 'drug_10mg']\n",
    "patient_list = ['Anna', 'John', 'Linzang', 'Corey', 'Mayuri', 'Ezra', 'Magneto']\n",
    "\n",
    "# your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54bfab44-915d-4d5c-acd4-7823e60b15e2",
   "metadata": {},
   "source": [
    "### Finite iterators\n",
    "These are tools that deal with tasks having a definite endpoint."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b0f6ff4-df9b-42bf-8eee-e80bfc93b850",
   "metadata": {},
   "source": [
    "#### chain()\n",
    "`chain()` creates an iterator that links multiple sequences together. In data science, this can be useful for combining disparate data sets into a single sequence for easier analysis. Suppose you have quarterly sales data stored in different lists, and you want to analyze the sales data for the entire year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "578f7824-856a-4204-8a81-e02683639a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quarterly sales data for a year\n",
    "Q1_sales = [1000, 1100, 1050]\n",
    "Q2_sales = [1200, 1300, 1250]\n",
    "Q3_sales = [1100, 1000, 1150]\n",
    "Q4_sales = [1050, 1100, 1200]\n",
    "\n",
    "# Use chain to combine all the sales data\n",
    "annual_sales = list(itertools.chain(Q1_sales, Q2_sales, Q3_sales, Q4_sales))\n",
    "\n",
    "print(annual_sales)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9fd5439-8e0e-4f4e-8c18-56341710d9e3",
   "metadata": {},
   "source": [
    "`chain` yields the elements of the first iterator until it gets exhausted, and then it yields the elements of the second one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd83419f-e9d3-454b-9874-90901fa64e29",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "de4a414e-b8c4-4e80-8458-04a98d45b5dd",
   "metadata": {},
   "source": [
    "#### compress()\n",
    "`compress()` produces an iterator that filters elements from an input sequence based on another iterable containing Boolean (True/False) values. In this sense, it is similar to `filter`, except that the `compress` method is much faster than the `filter` method. <br><br>\n",
    "Let’s say you have a list of product reviews and a corresponding list that marks each review as either relevant or not relevant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae86759d-cbb6-4048-b9c4-9771ee406f61",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Product reviews\n",
    "reviews = [\"Great!\", \"Bad!\", \"Average.\", \"Excellent!\", \"Poor!\"]\n",
    "\n",
    "# Relevance flags: 1 for relevant, 0 for irrelevant\n",
    "relevance_flags = [1, 0, 0, 1, 0]\n",
    "\n",
    "# Use compress to keep only relevant reviews\n",
    "relevant_reviews = list(itertools.compress(reviews, relevance_flags))\n",
    "\n",
    "print(relevant_reviews)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d1b1c05-98ec-4ba7-b6b8-3e1465a2af31",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "68ec865d-6184-499f-9dbd-d268a2a5e000",
   "metadata": {},
   "source": [
    "#### dropwhile()\n",
    "`dropwhile(func, seq)` creates an iterator that drops elements from an input sequence as long as a given condition is true. <br>\n",
    "In data science, this function is useful for ignoring a segment of data that doesn't meet certain criteria.<br><br>\n",
    "For instance, if you're analyzing website traffic and want to focus only on periods of high activity, `dropwhile()` can help you ignore low-traffic intervals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0e5ef81-03f2-4b94-b923-769b9d96272a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hourly website traffic counts\n",
    "traffic_data = [10, 12, 8, 15, 20, 25, 30, 10, 5, 8]\n",
    "\n",
    "# Function to check for low traffic\n",
    "def is_low_traffic(x):\n",
    "    return x < 15\n",
    "\n",
    "# Use dropwhile to ignore low-traffic hours\n",
    "high_traffic_data = list(itertools.dropwhile(is_low_traffic, traffic_data))\n",
    "\n",
    "print(high_traffic_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4706ab7-d551-4898-b6b0-45e60e81a92b",
   "metadata": {},
   "source": [
    "In this code, `dropwhile()` uses the `is_low_traffic` function to skip over the first elements that are below 15. Once it encounters an element that is 15 or higher, it includes all elements after that. The result is a new list that starts from the first high-traffic hour. This is handy in data science to focus on segments of data that are relevant to the analysis, allowing for more targeted insights."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ea97d3c-de5f-4174-8ce3-c7ad8c747717",
   "metadata": {},
   "source": [
    "#### takewhile()\n",
    "Similarly, its counterpart `takewhile()` allows considering an item from the iterable until the specified predicate becomes false for the first time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd5eefef-af04-4d7c-8f90-3fbb49057bd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use takewhile to only keep low-traffic hours\n",
    "low_traffic_data = list(itertools.takewhile(is_low_traffic, traffic_data))\n",
    "print(low_traffic_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c24a47-d111-49be-b32a-b1ebef546aed",
   "metadata": {},
   "source": [
    "Why did `takewhile()` not return the other elements at the end of traffic_data that were smaller than 15?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ffc6206-75c2-4e52-abed-ae1cce2d722a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "48475960-9dc3-43f3-9646-3b97a8e089c7",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "You have the a company's stock data in terms of percent growth per year. You want to find a streak of good performace whene company stock growth was positive. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d02e619-7bba-412d-aaa7-b0e03b287b11",
   "metadata": {},
   "outputs": [],
   "source": [
    "# percent growth per year\n",
    "value_list =[5, 6, -8, -4, 2] \n",
    "\n",
    "# your code here\n",
    "# Hint: define a function to test for positive growth in a given year\n",
    "def is_positive(n):\n",
    "    ...\n",
    "\n",
    "\n",
    "result = list(itertools....(function, sequence))\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d56c262-bc98-4e78-9b53-e0ca794be86e",
   "metadata": {},
   "source": [
    "### Combinatoric iterators\n",
    "These are special tools designed to perform combinations, permutations, and cross-products. They are extremely useful when we need to explore all possible scenarios or arrangements in data science tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01d41717-3ad2-437a-af30-ca129cfb97a1",
   "metadata": {},
   "source": [
    "#### product()\n",
    "`product()` creates an iterator that produces the Cartesian product of input iterables.<br>\n",
    "In data science, this function is particularly useful for generating all possible combinations of different sets of parameters for model tuning.\n",
    "\n",
    "Imagine you want to try out various combinations of learning rates and batch sizes to optimize a machine-learning model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35b4818b-016c-4bb8-84f6-73a4444ebc6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Possible learning rates and batch sizes\n",
    "learning_rates = [0.01, 0.1, 0.5]\n",
    "batch_sizes = [32, 64, 128]\n",
    "\n",
    "# Generate all combinations using product\n",
    "parameter_combinations = list(itertools.product(learning_rates, batch_sizes))\n",
    "\n",
    "print(parameter_combinations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f61a385-cbad-409a-8974-b61aa924744d",
   "metadata": {},
   "source": [
    "`product()` takes two lists: `learning_rates` and `batch_sizes`. It then creates an iterator that gives you all possible pairs between these two lists. The result, `parameter_combinations`, includes all possible combinations of learning rates and batch sizes.\n",
    "\n",
    "This helps in running experiments to fine-tune machine learning models, allowing you to test each combination systematically."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e538a8-d2ed-44d9-8884-3c19baee6d21",
   "metadata": {},
   "source": [
    "#### permutations()\n",
    "`permutations()` creates an iterator that produces all possible arrangements of an input iterable.<br> \n",
    "\n",
    "For example, say you have 5 political candidates, and you want to generate every possible scenario of a poll-result - where a President and a Vice-President are chosen. Here, the order matters since the first candidate will be president and the second candidate will be vice-president."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a43a6b3-3f0e-43cf-a43b-c861f914c387",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Candidates\n",
    "candidates = ['A' , 'B', 'C', 'D', 'E']\n",
    "\n",
    "# Generate all permutations of features\n",
    "candidate_permutations = list(itertools.permutations(candidates, 2)) # \n",
    "\n",
    "print(candidate_permutations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "482e0508-3875-4ba8-b911-1e151aaea5d9",
   "metadata": {},
   "source": [
    "`permutations()` takes the list features and the integer 2, which specifies the length of the permutations we want to generate. The output gives you all 2-element arrangements of the given features."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8cfeea5-1c5f-4216-a516-7355c39e48f5",
   "metadata": {},
   "source": [
    "#### combinations()\n",
    "`combinations()` creates an iterator over unique combinations of elements from an input iterable.<br>\n",
    "In data science, you often face problems where you need to select a subset of features to feed into a model.\n",
    "\n",
    "Imagine you have a dataset with columns like 'Age', 'Salary', and 'Years of Experience'. Using `combinations()`, you could generate all possible pairs or triplets of these columns to find the most predictive set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34af43ff-8e86-4cb7-a8db-822767041dd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List of features in a dataset\n",
    "features = ['Age', 'Salary', 'Years of Experience']\n",
    "\n",
    "# Generate all 2-element combinations of features\n",
    "feature_combinations = list(itertools.combinations(features, 2))\n",
    "\n",
    "print(feature_combinations)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b2e8154-4595-476c-bbb8-f02c749099a8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-05-01T15:37:34.381979Z",
     "iopub.status.busy": "2024-05-01T15:37:34.381586Z",
     "iopub.status.idle": "2024-05-01T15:37:34.388422Z",
     "shell.execute_reply": "2024-05-01T15:37:34.386903Z",
     "shell.execute_reply.started": "2024-05-01T15:37:34.381952Z"
    }
   },
   "source": [
    "This code takes the list of features and generates all unique 2-element combinations. You could then use this output to train your model with different feature sets.\n",
    "\n",
    "The idea is to find out which group of features makes your model the most accurate. This can help you improve model performance without adding extra complexity."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe71e9ee-f7bf-42c3-90b1-15bd089f5eb6",
   "metadata": {},
   "source": [
    "### Exercise 4\n",
    "You are building a machine learning model which takes in genetic sequences of length 3 and predicts how immunogenic the sequence is.\n",
    "You want to start with the sequence below and test all possible sequences to find out the most immunogenic sequence in order to design your world-saving vaccine. How would you do this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50fc3c88-2583-489b-ab01-abe669e3daef",
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence = ['T', 'A', 'G', 'C']\n",
    "\n",
    "# your code here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74848213-eb0f-4e84-b844-35ca55560f67",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "51e0ce9f-ac6b-46c0-a6e0-eb0afdf64117",
   "metadata": {},
   "source": [
    "**Acknowledgements**: https://www.stratascratch.com/blog/using-python-itertools-for-efficient-looping/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}