init

Author: Justine Wezenaar

README.md

@@ -0,0 +1,63 @@
+# ghc2024-vectorization-workshop
+
+## Set-Up
+
+### Option 1: From your local Python3 shell:
+
+0. Clone this repo (optionally: fork it to your github first)
+
+```
+git clone <>
+```
+
+1. Enter the directory and make your virtual environment (any Python3 version should be fine. Here I use 3.9)
+
+```
+cd ghc2024-vectorization-workshop
+python3.9 -m venv venv
+```
+
+2. Activate your new virtual environment
+```
+source venv/bin/activate
+```
+
+3. Install required packages from the requirements.txt
+```
+python -m pip install -r requirements.txt
+```
+
+### Option 2: In a Google Colab Notebook
+
+1. Open a new Google Colab Notebook (https://colab.research.google.com). You will need to be signed into your own Google account
+
+2. copy-paste the code from `utils.py` into the first cell and run
+
+## Writing and testing the functions
+
+### Option 1: From your local Python3 shell:
+
+1. Open the `q#.py` in your text editor, according to the question (q1 through q7). For the given question, put your optimized code in the `vec_*` function where it says `pass # insert your code here`.
+
+2. To test that your function works and compare the speed (for relevent questions) by running the `test_run.py` script:
+
+```
+python test_run.py
+```
+
+Note: if you're having trouble with one function and want to skip to the next one, just use `#` to comment out that line in the `test_run.py`
+
+If your function matches the desired output, then you should see either a "Success" message, or a printout of the timing differences.
+
+### Option 2: In a Google Colab Notebook
+
+1. Copy the code from the `q#.py` for your corresponding question (q1 through q7). Be sure to include the imports too, EXCEPT **do not include the line `from util import print_time_results, time_funcs`. You have already pasted these functions into your notebook during the Setup.
+
+2. Update the `vec_*` function where it says `pass # insert your code here`.
+
+3. Run the `test_*` function to determine if your output is satisfactory, and what the speedup is (for relevent questions). You won't use the `test_run.py` script if you're working in a Notebook; just copy-paste the `test_` functions directly and run them.
+
+## Brag about your gains!
+
+1. Go to the Google Form https://forms.gle/9xrjTUSEDozPm4kJ6 and report the speed-up factor you acheived for each function! We'll shout-out the biggest speed-ups live in the workshop.
+

q1.py

@@ -0,0 +1,34 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q1: Convert a list to np.array
+
+
+def convert_list_to_array(input_list: list):
+    pass  # insert your code here
+
+
+def make_test_list(size: int = 100):
+    return [i for i in range(size)]
+
+
+def test_convert_list(size: int = 1000):
+    print("\n\nQ1: Running test_convert_list...\n")
+    input = make_test_list(size)
+    output = convert_list_to_array(input)
+    if output is not None:
+        assert (
+            type(output) == np.ndarray
+            and len(input) == len(output)
+            and np.all([input[i] == output[i] for i in range(len(input))])
+        ), "Whoops! input and output do not match"
+        print("  Success!")
+    else:
+        print("  convert_list_to_array is not implemented")

q2.py

@@ -0,0 +1,34 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q2: Convert a dict to pd.DataFrame. Each key in the dict should become a column in the DataFrame.
+
+
+def convert_dict_to_df(input_dict: dict):
+    pass  # insert your code here
+
+
+def make_test_dict(size: int = 100):
+    return {
+        chr(97 + i % 26) * (i // 26 + 1): np.random.rand(5) * 100 for i in range(size)
+    }
+
+
+def test_convert_dict(size: int = 1000):
+    print("\n\nQ2: Running test_convert_dict...\n")
+    input = make_test_dict(size)
+    output = convert_dict_to_df(input)
+    if output is not None:
+        assert type(output) == pd.DataFrame and np.all(
+            [key in output.columns for key in input.keys()]
+        ), "Whoops! input and output do not match"
+        print("  Success!")
+    else:
+        print("  convert_dict_to_df is not implemented")

q3.py

@@ -0,0 +1,49 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q3: Write a vectorized function vec_power which has the same arguments are returns as slow_power. Run the function on data1 and report your speedup on 20 reps
+
+
+def slow_power(x, m=4):
+    out = []
+    for x_i in x:
+        out.append(x_i**m)
+    return np.array(out)
+
+
+def vec_power(x, m=4):
+    pass  # insert your new code here
+
+
+def make_data1(size=1000):
+    np.random.seed(4)
+    array1 = np.random.rand(size, 1)  # np.array
+    df1 = pd.DataFrame(array1)  # pd.DataFrame
+    return df1
+
+
+def test_power(size=1000):
+    print("\n\nQ3: Running test_power...\n")
+    input = make_data1(size=size)
+    output_slow = pd.DataFrame(slow_power(input[0]))
+    output_vec_raw = vec_power(input[0])
+    if output_vec_raw is not None:
+        output_vec = pd.DataFrame(output_vec_raw)
+        pd.testing.assert_frame_equal(output_slow, output_vec, check_dtype=False)
+        print("  Success!")
+        timings, _ = time_funcs(
+            [slow_power, vec_power],
+            [[input[0]], [input[0]]],
+            ["slow_power", "vec_power"],
+            reps=20,
+        )
+        print_time_results(timings, size)
+    else:
+        print("  vec_power is not implemented")

q4.py

@@ -0,0 +1,48 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q4: Write a vectorized function, vec_addition, which adds two vectors of the same size
+
+
+def slow_addition(arr1, arr2):
+    assert len(arr1) == len(arr2)
+    out = [a1 + a2 for a1, a2 in zip(arr1, arr2)]
+    return np.array(out)
+
+
+def vec_addition(arr1, arr2):
+    pass  # insert your code here
+
+
+def make_data1(size=1000):
+    np.random.seed(4)
+    array1 = np.random.rand(size, 1)  # np.array
+    df1 = pd.DataFrame(array1)  # pd.DataFrame
+    return df1
+
+
+def test_addition(size=1000):
+    print("\n\nQ4: Running test_addition...\n")
+    input_1 = make_data1(size=size)
+    input_2 = make_data1(size=size)
+    output_slow = pd.DataFrame(slow_addition(input_1[0], input_2[0]))
+    output_vec = vec_addition(input_1[0], input_2[0])
+    if output_vec is not None:
+        output_vec_df = pd.DataFrame(output_vec)
+        pd.testing.assert_frame_equal(output_slow, output_vec_df, check_dtype=False)
+        timings, _ = time_funcs(
+            [slow_addition, vec_addition],
+            [(input_1[0], input_2[0]), (input_1[0], input_2[0])],
+            ["slow_addition", "vec_addition"],
+            reps=20,
+        )
+        print_time_results(timings, size)
+    else:
+        print("  vec_addition is not implemented")

q5.py

@@ -0,0 +1,55 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q5: Write a vectorized function, vec_grade, which has the same arguments and return as slow_grade.
+# Note that when evaluating multiple boolean conditions over a vector, bitwise operators must be used
+# Example: indices_of_nums_bt_1_and_5 = (some_other_vector > 1) & (some_other_vector < 5)
+
+
+def slow_grade(grades):
+    letter_grades = []
+    for grade in grades:
+        if grade >= 90:
+            letter_grades.append("A")
+        elif 80 <= grade <= 90:
+            letter_grades.append("B")
+        elif 70 <= grade <= 80:
+            letter_grades.append("C")
+        elif grade < 70:
+            letter_grades.append("F")
+
+    return np.array(letter_grades)
+
+
+def vec_grade(grades):
+    pass  # insert your code here
+
+
+def random_grades(num_grades: int):
+    return np.random.randint(0, 100, size=num_grades)
+
+
+def test_grades(num_grades: int = 1000):
+    print("\n\nQ5: Running test_grades...\n")
+    input = random_grades(num_grades)
+    output_slow = pd.DataFrame(slow_grade(input))
+    output_vec = vec_grade(input)
+    if output_vec is not None:
+        output_vec_df = pd.DataFrame(output_vec)
+        pd.testing.assert_frame_equal(output_slow, output_vec_df, check_dtype=False)
+        timings, _ = time_funcs(
+            [slow_grade, vec_grade],
+            [[input], [input]],
+            ["slow_grade", "vec_grade"],
+            reps=20,
+        )
+        print_time_results(timings, num_grades)
+    else:
+        print("  vec_grade is not implemented")

q6.py

@@ -0,0 +1,54 @@
+"""Unoptimized functions to be vectorized."""
+
+import math
+import time
+
+import numpy as np
+import pandas as pd
+
+from util import print_time_results, time_funcs
+
+# Q6: Write a vectorized function, vec_pass_fail, which has the same arguments and returns as slow_pass_fail.
+# (Hint: try using np.where and np.isin)
+
+
+def slow_pass_fail(grades):
+    pass_fail_grades = []
+    for grade in grades:
+        if grade == "A":
+            pass_fail_grades.append("P")
+        elif grade == "B":
+            pass_fail_grades.append("P")
+        elif grade == "C":
+            pass_fail_grades.append("P")
+        else:
+            pass_fail_grades.append("F")
+
+    return np.array(pass_fail_grades)
+
+
+def vec_pass_fail(grades):
+    pass  # insert your code here
+
+
+def random_grades(num_grades: int):
+    return np.random.randint(0, 100, size=num_grades)
+
+
+def test_pass_fail(num_grades: int = 1000):
+    print("\n\nQ6: Running test_pass_fail...\n")
+    input = random_grades(num_grades)
+    output_slow = pd.DataFrame(slow_pass_fail(input))
+    output_vec = vec_pass_fail(input)
+    if output_vec is not None:
+        output_vec_df = pd.DataFrame(output_vec)
+        pd.testing.assert_frame_equal(output_slow, output_vec_df, check_dtype=False)
+        timings, _ = time_funcs(
+            [slow_pass_fail, vec_pass_fail],
+            [[input], [input]],
+            ["slow_pass_fail", "vec_pass_fail"],
+            reps=20,
+        )
+        print_time_results(timings, num_grades)
+    else:
+        print("  vec_pass_fail is not implemented")