From 572d6b1ca853a5b3228cdb25c202a09b01ce5754 Mon Sep 17 00:00:00 2001 From: ligerfotis Date: Thu, 27 Apr 2023 15:24:21 +0200 Subject: [PATCH] update solutions --- assignment 1/iml_assignment1_solved.ipynb | 1180 ++++++++--------- assignment 2/assignment2_bonus_solved.ipynb | 199 +++ assignment 2/assignment2_bonus_unsolved.ipynb | 282 ++-- assignment 2/iml_assignment2a_solved.ipynb | 11 + assignment 2/iml_assignment2b_solved.ipynb | 22 +- 5 files changed, 951 insertions(+), 743 deletions(-) create mode 100644 assignment 2/assignment2_bonus_solved.ipynb diff --git a/assignment 1/iml_assignment1_solved.ipynb b/assignment 1/iml_assignment1_solved.ipynb index 6d1b155..eb8b4ce 100644 --- a/assignment 1/iml_assignment1_solved.ipynb +++ b/assignment 1/iml_assignment1_solved.ipynb @@ -1,598 +1,598 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.3" - }, - "colab": { - "provenance": [] - } + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" }, - "cells": [ + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "colab": { + "provenance": [] + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "whjkuflGLNWu" + }, + "source": [ + "# Fibonacci Solver\n", + "\n", + "The Fibonacci Sequence is the series of numbers:\n", + "\n", + "` 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... `\n", + "\n", + "The next number is found by adding up the two numbers before it:\n", + "\n", + "the `2` is found by adding the two numbers before it `(1+1)`,\n", + "the `3` is found by adding the two numbers before it `(1+2)`,\n", + "the `5` is `(2+3)`,\n", + "and so on!\n", + "\n", + "## Coding it up in Python\n", + "Just initialize to variables with the first two numbers of the Fibonacci sequence. Then add them up and print the result.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "p58ac2HULNWv" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "result = first_number + second_number\n", + "\n", + "print(result)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xSyPoS1bLNWy" + }, + "source": [ + "You now need to do this multiple times, so you need a ***loop***\n", + "To use a loop you need to know how many times you want to loop for. \n", + "For now, create a loop that prints **20** numbers (from 0 to 19). To do this in python you can create a ***for loop*** using the `range` function which will run the function for every number in the range.\n", + "(TIP: Python is a ***0 based*** language which means it starts counting from 0 not 1 as a human normally would.)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tTsWxVxMLNWy" + }, + "source": [ + "for count in range(20):\n", + " print(count)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "INNU9p8zLNW0" + }, + "source": [ + "Now use the loop to compute the first 20 elements of the Fibonacci sequence." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "4Hf59jqgLNW1" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "for count in range(20):\n", + " result = first_number + second_number\n", + " print(result)\n", + " first_number = second_number\n", + " second_number = result" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bScJ-6tULNW3" + }, + "source": [ + "If you managed it till here great job!\n", + "Is seems to work great so far, but you need to store these numbers so you can reference them when needed." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1VhirrXpLNW3" + }, + "source": [ + "Create an empty ***array*** called `fibonacci` and then append the elements of the sequence to it." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "thTMoVY2LNW3" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "fibonacci = []\n", + "\n", + "fibonacci.append(first_number)\n", + "fibonacci.append(second_number)\n", + "\n", + "for count in range(20):\n", + " result = first_number + second_number\n", + " # print(result)\n", + " fibonacci.append(result)\n", + " first_number = second_number\n", + " second_number = result\n", + " \n", + "print(fibonacci)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6nlc_cC7LNW5" + }, + "source": [ + "If everything worked according to the plan, you should be able to access any of the first 20 elements of the Fibonacci sequence at will.\n", + "\n", + "eg `fibonacci[0]` would get us the first item in the array whilst `fibonacci[9]` would get us the tenth item (remember Python is 0 based so you always need to take 1 away from the number you need)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "yEKa7pAuLNW6" + }, + "source": [ + "fibonacci[0]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "1wbxOVnELNW7" + }, + "source": [ + "fibonacci[9]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "50FpCM7CLNW9" + }, + "source": [ + "So now you know how to get at the index, you need to know which index values are asked for by the user.\n", + "Lets get some input from the user." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YIJRBUXWLNW-", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 53 + }, + "outputId": "aaadcdb4-2317-4b63-c306-3256393a1875" + }, + "source": [ + "input()" + ], + "execution_count": null, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "whjkuflGLNWu" - }, - "source": [ - "# Fibonacci Solver\n", - "\n", - "The Fibonacci Sequence is the series of numbers:\n", - "\n", - "` 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... `\n", - "\n", - "The next number is found by adding up the two numbers before it:\n", - "\n", - "the `2` is found by adding the two numbers before it `(1+1)`,\n", - "the `3` is found by adding the two numbers before it `(1+2)`,\n", - "the `5` is `(2+3)`,\n", - "and so on!\n", - "\n", - "## Coding it up in Python\n", - "Just initialize to variables with the first two numbers of the Fibonacci sequence. Then add them up and print the result.\n" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] }, { - "cell_type": "code", - "metadata": { - "id": "p58ac2HULNWv" - }, - "source": [ - "# Starting Point\n", - "first_number = 0\n", - "second_number = 1\n", - "result = first_number + second_number\n", - "\n", - "print(result)" + "output_type": "execute_result", + "data": { + "text/plain": [ + "'2'" ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xSyPoS1bLNWy" - }, - "source": [ - "You now need to do this multiple times, so you need a ***loop***\n", - "To use a loop you need to know how many times you want to loop for. \n", - "For now, create a loop that prints **20** numbers (from 0 to 19). To do this in python you can create a ***for loop*** using the `range` function which will run the function for every number in the range.\n", - "(TIP: Python is a ***0 based*** language which means it starts counting from 0 not 1 as a human normally would.)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "tTsWxVxMLNWy" - }, - "source": [ - "for count in range(20):\n", - " print(count)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "INNU9p8zLNW0" - }, - "source": [ - "Now use the loop to compute the first 20 elements of the Fibonacci sequence." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4Hf59jqgLNW1" - }, - "source": [ - "# Starting Point\n", - "first_number = 0\n", - "second_number = 1\n", - "\n", - "for count in range(20):\n", - " result = first_number + second_number\n", - " print(result)\n", - " first_number = second_number\n", - " second_number = result" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bScJ-6tULNW3" - }, - "source": [ - "If you managed it till here great job!\n", - "Is seems to work great so far, but you need to store these numbers so you can reference them when needed." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1VhirrXpLNW3" - }, - "source": [ - "Create an empty ***array*** called `fibonacci` and then append the elements of the sequence to it." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "thTMoVY2LNW3" - }, - "source": [ - "# Starting Point\n", - "first_number = 0\n", - "second_number = 1\n", - "\n", - "fibonacci = []\n", - "\n", - "fibonacci.append(first_number)\n", - "fibonacci.append(second_number)\n", - "\n", - "for count in range(20):\n", - " result = first_number + second_number\n", - " # print(result)\n", - " fibonacci.append(result)\n", - " first_number = second_number\n", - " second_number = result\n", - " \n", - "print(fibonacci)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6nlc_cC7LNW5" - }, - "source": [ - "If everything worked according to the plan, you should be able to access any of the first 20 elements of the Fibonacci sequence at will.\n", - "\n", - "eg `fibonacci[0]` would get us the first item in the array whilst `fibonacci[9]` would get us the tenth item (remember Python is 0 based so you always need to take 1 away from the number you need)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yEKa7pAuLNW6" - }, - "source": [ - "fibonacci[0]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "1wbxOVnELNW7" - }, - "source": [ - "fibonacci[9]" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "50FpCM7CLNW9" - }, - "source": [ - "So now you know how to get at the index, you need to know which index values are asked for by the user.\n", - "Lets get some input from the user." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "YIJRBUXWLNW-", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 53 - }, - "outputId": "aaadcdb4-2317-4b63-c306-3256393a1875" - }, - "source": [ - "input()" - ], - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "'2'" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - } - }, - "metadata": {}, - "execution_count": 12 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Get the first index from the user" - ], - "metadata": { - "id": "5Vp9iO2r2e2S" + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" } - }, - { - "cell_type": "code", - "source": [ - "first_index = input()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Zj6mnXCI2mNo", - "outputId": "8404c9dd-b5f0-42ec-97bd-d57abebafbed" - }, - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Get the second index from the user" - ], - "metadata": { - "id": "9LDXbzP02rFa" - } - }, - { - "cell_type": "code", - "metadata": { - "id": "wqbTuR2TLNXA", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "66aecb44-52c6-44f3-95a7-140c1dce6fe1" - }, - "source": [ - "second_index = input()" - ], - "execution_count": null, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Print the received inputs and their types" - ], - "metadata": { - "id": "EK9FMjJV22x9" - } - }, - { - "cell_type": "code", - "metadata": { - "id": "xfy81HrsLNXC", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "fd3d4b7d-88c7-4e1e-9486-3a0718dfa737" - }, - "source": [ - "print(first_index)\n", - "print(type(first_index))\n", - "print(second_index)\n", - "print(type(second_index))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2\n", - "\n", - "2\n", - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ttb_0MejLNXE" - }, - "source": [ - "The value received from input will be treated as a string type, you need to convert this to a number so python knows to treat it as one." - ] - }, - { - "cell_type": "code", - "source": [ - "first_index = int(first_index)\n", - "second_index = int(second_index)" - ], - "metadata": { - "id": "RwVoHTLn6QvB" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Print the type of the transformed variables." - ], - "metadata": { - "id": "pxKx8gKy2-eh" - } - }, - { - "cell_type": "code", - "source": [ - "type(first_index)\n", - "type(second_index)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "dN_EzHKr3GmO", - "outputId": "c45cdbad-5e51-457a-83d5-57e92e2b44c4" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "int" - ] - }, - "metadata": {}, - "execution_count": 11 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CRuAEA7KLNXE" - }, - "source": [ - "Now you have all the parts you need to make this work. \n", - "\n", - "* The user should be prompted \"How many results would you like?\"\n", - "* The program should read the users preference, e.g. 20, and then compute the list of elements up to this number.\n", - "* Then the program should ask the user for 2 indexes within the list of the calculated Fibonacci sequence\n", - "* Finally it should print the summation of their values.\n", - "\n", - "Time to put it together:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ukW0WUA7LNXE", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "f1d134d8-61f7-4f93-a54b-d63dffe08964" - }, - "source": [ - "# Starting Point\n", - "first_number = 0\n", - "second_number = 1\n", - "\n", - "fibonacci = []\n", - "\n", - "fibonacci.append(first_number)\n", - "fibonacci.append(second_number)\n", - "\n", - "print(\"##### GENERATING FIBONACCI LIST #####\")\n", - "fib_range = int(input(\"How many results would you like?\"))\n", - "for count in range(fib_range-2):\n", - " result = first_number + second_number\n", - " # print(result)\n", - " fibonacci.append(result)\n", - " first_number = second_number\n", - " second_number = result\n", - "\n", - "print(\"##### COMPLETED MAKING FIBONACCI LIST #####\")\n", - "\n", - "\n", - "first_index = int(input(\"Please enter the first number you require?\"))\n", - "second_index = int(input(\"Please enter the second number you require?\"))\n", - "\n", - "print(\"##### GETTING RESULT #####\")\n", - "final_answer = fibonacci[first_index-1] + fibonacci[second_index-1]\n", - "print(\"\\n\\nThe answer is:\\n\\n{}\".format(final_answer))" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "##### GENERATING FIBONACCI LIST #####\n", - "How many results would you like?10\n", - "##### COMPLETED MAKING FIBONACCI LIST #####\n", - "Please enter the first number you require?10\n", - "Please enter the second number you require?9\n", - "##### GETTING RESULT #####\n", - "\n", - "\n", - "The answer is:\n", - "\n", - "55\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Finally plot the first 30 elements of the Fibonacci sequence using matplotlib" - ], - "metadata": { - "id": "qqMN0OEjEyPN" - } - }, - { - "cell_type": "code", - "metadata": { - "id": "edzR_wahLNXG", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 282 - }, - "outputId": "bb9ad5f3-811d-4687-adb0-432d3ed72ab9" - }, - "source": [ - "import matplotlib.pyplot as plt\n", - "plt.plot(fibonacci)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "[]" - ] - }, - "metadata": {}, - "execution_count": 13 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Compute the Fibonacci sequence recursively" - ], - "metadata": { - "id": "AA67da2KzQnL" - } - }, - { - "cell_type": "code", - "source": [ - "def fibonacci_recursive(n):\n", - " if n < 2:\n", - " return n\n", - " return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)" - ], - "metadata": { - "id": "jJppjtZAzT80" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "print(\"##### GENERATING FIBONACCI LIST #####\")\n", - "fib_range = int(input(\"How many results would you like?\"))\n", - "for i in range(fib_range):\n", - " print(fibonacci_recursive(i))" - ], - "metadata": { - "id": "1GDrTgOhz7TM", - "outputId": "c1007637-9156-417d-f973-77a3577857a2", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "##### GENERATING FIBONACCI LIST #####\n", - "How many results would you like?20\n", - "0\n", - "1\n", - "1\n", - "2\n", - "3\n", - "5\n", - "8\n", - "13\n", - "21\n", - "34\n", - "55\n", - "89\n", - "144\n", - "233\n", - "377\n", - "610\n", - "987\n", - "1597\n", - "2584\n", - "4181\n" - ] - } - ] + }, + "metadata": {}, + "execution_count": 12 } - ] -} \ No newline at end of file + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get the first index from the user" + ], + "metadata": { + "id": "5Vp9iO2r2e2S" + } + }, + { + "cell_type": "code", + "source": [ + "first_index = input()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Zj6mnXCI2mNo", + "outputId": "8404c9dd-b5f0-42ec-97bd-d57abebafbed" + }, + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get the second index from the user" + ], + "metadata": { + "id": "9LDXbzP02rFa" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "wqbTuR2TLNXA", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "66aecb44-52c6-44f3-95a7-140c1dce6fe1" + }, + "source": [ + "second_index = input()" + ], + "execution_count": null, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Print the received inputs and their types" + ], + "metadata": { + "id": "EK9FMjJV22x9" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "xfy81HrsLNXC", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "fd3d4b7d-88c7-4e1e-9486-3a0718dfa737" + }, + "source": [ + "print(first_index)\n", + "print(type(first_index))\n", + "print(second_index)\n", + "print(type(second_index))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2\n", + "\n", + "2\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ttb_0MejLNXE" + }, + "source": [ + "The value received from input will be treated as a string type, you need to convert this to a number so python knows to treat it as one." + ] + }, + { + "cell_type": "code", + "source": [ + "first_index = int(first_index)\n", + "second_index = int(second_index)" + ], + "metadata": { + "id": "RwVoHTLn6QvB" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Print the type of the transformed variables." + ], + "metadata": { + "id": "pxKx8gKy2-eh" + } + }, + { + "cell_type": "code", + "source": [ + "type(first_index)\n", + "type(second_index)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dN_EzHKr3GmO", + "outputId": "c45cdbad-5e51-457a-83d5-57e92e2b44c4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "int" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CRuAEA7KLNXE" + }, + "source": [ + "Now you have all the parts you need to make this work. \n", + "\n", + "* The user should be prompted \"How many results would you like?\"\n", + "* The program should read the users preference, e.g. 20, and then compute the list of elements up to this number.\n", + "* Then the program should ask the user for 2 indexes within the list of the calculated Fibonacci sequence\n", + "* Finally it should print the summation of their values.\n", + "\n", + "Time to put it together:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ukW0WUA7LNXE", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1d134d8-61f7-4f93-a54b-d63dffe08964" + }, + "source": [ + "# Starting Point\n", + "first_number = 0\n", + "second_number = 1\n", + "\n", + "fibonacci = []\n", + "\n", + "fibonacci.append(first_number)\n", + "fibonacci.append(second_number)\n", + "\n", + "print(\"##### GENERATING FIBONACCI LIST #####\")\n", + "fib_range = int(input(\"How many results would you like?\"))\n", + "for count in range(fib_range-2):\n", + " result = first_number + second_number\n", + " # print(result)\n", + " fibonacci.append(result)\n", + " first_number = second_number\n", + " second_number = result\n", + "\n", + "print(\"##### COMPLETED MAKING FIBONACCI LIST #####\")\n", + "\n", + "\n", + "first_index = int(input(\"Please enter the first number you require?\"))\n", + "second_index = int(input(\"Please enter the second number you require?\"))\n", + "\n", + "print(\"##### GETTING RESULT #####\")\n", + "final_answer = fibonacci[first_index-1] + fibonacci[second_index-1]\n", + "print(\"\\n\\nThe answer is:\\n\\n{}\".format(final_answer))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "##### GENERATING FIBONACCI LIST #####\n", + "How many results would you like?10\n", + "##### COMPLETED MAKING FIBONACCI LIST #####\n", + "Please enter the first number you require?10\n", + "Please enter the second number you require?9\n", + "##### GETTING RESULT #####\n", + "\n", + "\n", + "The answer is:\n", + "\n", + "55\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Finally plot the first 30 elements of the Fibonacci sequence using matplotlib" + ], + "metadata": { + "id": "qqMN0OEjEyPN" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "edzR_wahLNXG", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "bb9ad5f3-811d-4687-adb0-432d3ed72ab9" + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(fibonacci)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 13 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Compute the Fibonacci sequence recursively" + ], + "metadata": { + "id": "AA67da2KzQnL" + } + }, + { + "cell_type": "code", + "source": [ + "def fibonacci_recursive(n):\n", + " if n < 2:\n", + " return n\n", + " return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)" + ], + "metadata": { + "id": "jJppjtZAzT80" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(\"##### GENERATING FIBONACCI LIST #####\")\n", + "fib_range = int(input(\"How many results would you like?\"))\n", + "for i in range(fib_range):\n", + " print(fibonacci_recursive(i))" + ], + "metadata": { + "id": "1GDrTgOhz7TM", + "outputId": "c1007637-9156-417d-f973-77a3577857a2", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "##### GENERATING FIBONACCI LIST #####\n", + "How many results would you like?20\n", + "0\n", + "1\n", + "1\n", + "2\n", + "3\n", + "5\n", + "8\n", + "13\n", + "21\n", + "34\n", + "55\n", + "89\n", + "144\n", + "233\n", + "377\n", + "610\n", + "987\n", + "1597\n", + "2584\n", + "4181\n" + ] + } + ] + } + ] +} diff --git a/assignment 2/assignment2_bonus_solved.ipynb b/assignment 2/assignment2_bonus_solved.ipynb new file mode 100644 index 0000000..b00e1d2 --- /dev/null +++ b/assignment 2/assignment2_bonus_solved.ipynb @@ -0,0 +1,199 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "HoNMeHx5EDAm" + }, + "outputs": [], + "source": [ + "# By Univ.-Prof. Dr. Elmar Rueckert, 02.03.2022\n", + "# *******************************************************\n", + "\n", + "\n", + "import pickle, os\n", + "import numpy as np\n", + "from PIL import Image\n", + "from itertools import product" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Download the picture in this link https://cps.unileoben.ac.at/wp/DALL·E-2023-02-09-17.32.48-robot-hand-communicating-with-sign-language.png and add it to the repository.\n", + "Name it 'hand.png'" + ], + "metadata": { + "id": "6SMr_2ZyFQJ0" + } + }, + { + "cell_type": "markdown", + "source": [ + "The \"filtered\" callback function takes a kernel (k) and an image as inputs, and applies the convolution operation on the image using the kernel. It first calculates the offset value for the kernel based on its shape, and then creates a zero-filled array of the same shape as the input image. It then iterates through all the pixel coordinates of the image, and for each pixel, it extracts the corresponding kernel-sized sub-image from the input image. It then performs the element-wise multiplication between the sub-image and the kernel, and sums up the resulting values to get a single output value. This output value is then clipped between 0 and 255, and stored in the corresponding pixel location of the output image. Finally, the filtered image is returned as output." + ], + "metadata": { + "id": "DZgexX8UE0HV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "def filtered(k, image):\n", + " offset = int(np.floor(k.shape[0] / 2))\n", + " filtered_image = np.zeros(image.shape)\n", + " size = range(offset, filtered_image.shape[0] - offset)\n", + " for i, j in product(size, size):\n", + " image_part = image[i - offset:i + offset + 1, j - offset:j + offset + 1]\n", + " value = (image_part * k).sum()\n", + " filtered_image[i, j] = min(255, max(0, value))\n", + " # Return filtered image\n", + " return filtered_image" + ], + "metadata": { + "id": "pwuRm4gUE-eA" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Develop the image processing function that takes the filter and the callback as arguments" + ], + "metadata": { + "id": "zqrb5mT6EjRz" + } + }, + { + "cell_type": "code", + "source": [ + "def image_processing(k, callback):\n", + " # Acquire image\n", + " file_name = 'hand.png'\n", + " image = Image.open(file_name).convert('L')\n", + " image = np.array(image)\n", + "\n", + " filtered_image = callback(k, image)\n", + "\n", + " # Display image\n", + " image = Image.fromarray(image)\n", + " image.show()\n", + " image_tmp = Image.fromarray(filtered_image)\n", + " image_tmp.show()\n", + "\n" + ], + "metadata": { + "id": "wjdHq6ONEjau" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Main function" + ], + "metadata": { + "id": "h_yhIiCCEe_y" + } + }, + { + "cell_type": "code", + "source": [ + "if __name__ == '__main__':\n", + " # Laplace kernel\n", + " k_laplacian = np.asarray([[-1, -1, -1],\n", + " [-1, 8, -1],\n", + " [-1, -1, -1]])\n", + "\n", + " # Gaussian Smoothing Kernel\n", + " k_gaussian = np.asarray([[1, 1, 1],\n", + " [1, 1, 1],\n", + " [1, 1, 1]],dtype=float)\n", + " k_gaussian /= 9" + ], + "metadata": { + "id": "Y2-B4ii1EewG" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Image Processing" + ], + "metadata": { + "id": "XQdU2c8nEb5H" + } + }, + { + "cell_type": "code", + "source": [ + " image_processing(k_laplacian,filtered)" + ], + "metadata": { + "id": "1XN9C4p-EZTF" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "(eog:14526): EOG-CRITICAL **: 16:14:55.972: eog_image_get_file: assertion 'EOG_IS_IMAGE (img)' failed\n", + "\n", + "(eog:14526): GLib-GIO-CRITICAL **: 16:14:55.972: g_file_equal: assertion 'G_IS_FILE (file1)' failed\n" + ] + } + ], + "source": [ + " image_processing(k_gaussian, filtered)\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } + } + ] +} diff --git a/assignment 2/assignment2_bonus_unsolved.ipynb b/assignment 2/assignment2_bonus_unsolved.ipynb index 33af499..9d71800 100644 --- a/assignment 2/assignment2_bonus_unsolved.ipynb +++ b/assignment 2/assignment2_bonus_unsolved.ipynb @@ -1,143 +1,143 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] }, - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "HoNMeHx5EDAm" - }, - "outputs": [], - "source": [ - "# By Univ.-Prof. Dr. Elmar Rueckert, 02.03.2022\n", - "# *******************************************************\n", - "\n", - "\n", - "import pickle, os\n", - "import numpy as np\n", - "from PIL import Image\n", - "from itertools import product" - ] - }, - { - "cell_type": "markdown", - "source": [ - "Download the picture in this link https://cps.unileoben.ac.at/wp/DALL·E-2023-02-09-17.32.48-robot-hand-communicating-with-sign-language.png and add it to the repository.\n", - "Name it 'hand.png'" - ], - "metadata": { - "id": "6SMr_2ZyFQJ0" - } - }, - { - "cell_type": "markdown", - "source": [ - "The \"filtered\" callback function takes a kernel (k) and an image as inputs, and applies the convolution operation on the image using the kernel. It first calculates the offset value for the kernel based on its shape, and then creates a zero-filled array of the same shape as the input image. It then iterates through all the pixel coordinates of the image, and for each pixel, it extracts the corresponding kernel-sized sub-image from the input image. It then performs the element-wise multiplication between the sub-image and the kernel, and sums up the resulting values to get a single output value. This output value is then clipped between 0 and 255, and stored in the corresponding pixel location of the output image. Finally, the filtered image is returned as output." - ], - "metadata": { - "id": "DZgexX8UE0HV" - } - }, - { - "cell_type": "code", - "source": [ - "\n", - "def filtered(k, image):\n", - " \n", - " return filtered_image" - ], - "metadata": { - "id": "pwuRm4gUE-eA" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Develop the image processing function that takes the filter and the callback as arguments" - ], - "metadata": { - "id": "zqrb5mT6EjRz" - } - }, - { - "cell_type": "code", - "source": [ - "def image_processing(k, callback):\n", - " # Acquire image\n", - "\n", - " # Display image" - ], - "metadata": { - "id": "wjdHq6ONEjau" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Main function" - ], - "metadata": { - "id": "h_yhIiCCEe_y" - } - }, - { - "cell_type": "code", - "source": [ - "if __name__ == '__main__':\n", - " # Laplace kernel\n", - " k_laplacian = np.asarray([[-1, -1, -1],\n", - " [-1, 8, -1],\n", - " [-1, -1, -1]])\n", - "\n", - " # Gaussian Smoothing Kernel\n", - " k_gaussian = np.asarray([[1, 1, 1],\n", - " [1, 1, 1],\n", - " [1, 1, 1]],dtype=float)\n", - " k_gaussian /= 9" - ], - "metadata": { - "id": "Y2-B4ii1EewG" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Image Processing" - ], - "metadata": { - "id": "XQdU2c8nEb5H" - } - }, - { - "cell_type": "code", - "source": [ - " image_processing(k_laplacian,filtered)\n", - " image_processing(k_gaussian, filtered)" - ], - "metadata": { - "id": "1XN9C4p-EZTF" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HoNMeHx5EDAm" + }, + "outputs": [], + "source": [ + "# By Univ.-Prof. Dr. Elmar Rueckert, 02.03.2022\n", + "# *******************************************************\n", + "\n", + "\n", + "import pickle, os\n", + "import numpy as np\n", + "from PIL import Image\n", + "from itertools import product" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Download the picture in this link https://cps.unileoben.ac.at/wp/DALL·E-2023-02-09-17.32.48-robot-hand-communicating-with-sign-language.png and add it to the repository.\n", + "Name it 'hand.png'" + ], + "metadata": { + "id": "6SMr_2ZyFQJ0" + } + }, + { + "cell_type": "markdown", + "source": [ + "The \"filtered\" callback function takes a kernel (k) and an image as inputs, and applies the convolution operation on the image using the kernel. It first calculates the offset value for the kernel based on its shape, and then creates a zero-filled array of the same shape as the input image. It then iterates through all the pixel coordinates of the image, and for each pixel, it extracts the corresponding kernel-sized sub-image from the input image. It then performs the element-wise multiplication between the sub-image and the kernel, and sums up the resulting values to get a single output value. This output value is then clipped between 0 and 255, and stored in the corresponding pixel location of the output image. Finally, the filtered image is returned as output." + ], + "metadata": { + "id": "DZgexX8UE0HV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "def filtered(k, image):\n", + "\n", + " return filtered_image" + ], + "metadata": { + "id": "pwuRm4gUE-eA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Develop the image processing function that takes the filter and the callback as arguments" + ], + "metadata": { + "id": "zqrb5mT6EjRz" + } + }, + { + "cell_type": "code", + "source": [ + "def image_processing(k, callback):\n", + " # Acquire image\n", + "\n", + " # Display image" + ], + "metadata": { + "id": "wjdHq6ONEjau" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Main function" + ], + "metadata": { + "id": "h_yhIiCCEe_y" + } + }, + { + "cell_type": "code", + "source": [ + "if __name__ == '__main__':\n", + " # Laplace kernel\n", + " k_laplacian = np.asarray([[-1, -1, -1],\n", + " [-1, 8, -1],\n", + " [-1, -1, -1]])\n", + "\n", + " # Gaussian Smoothing Kernel\n", + " k_gaussian = np.asarray([[1, 1, 1],\n", + " [1, 1, 1],\n", + " [1, 1, 1]],dtype=float)\n", + " k_gaussian /= 9" + ], + "metadata": { + "id": "Y2-B4ii1EewG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Image Processing" + ], + "metadata": { + "id": "XQdU2c8nEb5H" + } + }, + { + "cell_type": "code", + "source": [ + " image_processing(k_laplacian,filtered)\n", + " image_processing(k_gaussian, filtered)" + ], + "metadata": { + "id": "1XN9C4p-EZTF" + }, + "execution_count": null, + "outputs": [] + } + ] +} diff --git a/assignment 2/iml_assignment2a_solved.ipynb b/assignment 2/iml_assignment2a_solved.ipynb index 4db0dc1..9933c9c 100644 --- a/assignment 2/iml_assignment2a_solved.ipynb +++ b/assignment 2/iml_assignment2a_solved.ipynb @@ -14,6 +14,17 @@ } }, "cells": [ + { + "cell_type": "markdown", + "source": [ + "### Solution for Assignment 2 of the course \"Introduction to Machine Learning\" at the University of Leoben.\n", + "##### Author: Fotios Lygerakis\n", + "##### Semester: SS 2022/2023" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "markdown", "source": [ diff --git a/assignment 2/iml_assignment2b_solved.ipynb b/assignment 2/iml_assignment2b_solved.ipynb index 03e3f08..c4e532e 100644 --- a/assignment 2/iml_assignment2b_solved.ipynb +++ b/assignment 2/iml_assignment2b_solved.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "outputs": [], "source": [ "import numpy as np" @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "outputs": [ { "name": "stdout", @@ -98,19 +98,18 @@ "[[5 1 3]\n", " [1 2 1]\n", " [1 2 1]]\n", - "[[1 2 3]]\n", - "[[16]\n", - " [ 8]\n", - " [ 8]]\n" + "[1 2 3]\n", + "[16 8 8]\n" ] } ], "source": [ "tmp_array = np.array([[5,1,3],[1,2,1],[1,2,1]])\n", - "tmp_array2 = np.array([[1,2,3]])\n", + "tmp_array2 = np.array([1,2,3])\n", "print(tmp_array)\n", "print(tmp_array2)\n", - "print(np.dot(tmp_array,tmp_array2.T))" + "# print dot product of tmp_array and tmp_array2\n", + "print(np.dot(tmp_array,tmp_array2))" ], "metadata": { "collapsed": false @@ -134,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "outputs": [ { "name": "stdout", @@ -142,8 +141,7 @@ "text": [ "[[4 1]\n", " [2 2]]\n", - "[[1]\n", - " [2]]\n" + "[1 2]\n" ] } ], @@ -153,7 +151,7 @@ "B = np.array([[4,1],[2,2]])\n", "print(np.dot(A,B))\n", "# A*c\n", - "c = np.array([[1,2]])\n", + "c = np.array([1,2])\n", "print(np.dot(A,c.T))" ], "metadata": {