From 047410d149250c93127e78aa49ee6d382d5aed37 Mon Sep 17 00:00:00 2001 From: ligerfotis Date: Fri, 31 Mar 2023 13:53:42 +0200 Subject: [PATCH] update solutions --- assignment 2/iml_assignment2a_solved.ipynb | 250 +++++++++++++ assignment 2/iml_assignment2b_solved.ipynb | 394 +++++++++++++++++++++ 2 files changed, 644 insertions(+) create mode 100644 assignment 2/iml_assignment2a_solved.ipynb create mode 100644 assignment 2/iml_assignment2b_solved.ipynb diff --git a/assignment 2/iml_assignment2a_solved.ipynb b/assignment 2/iml_assignment2a_solved.ipynb new file mode 100644 index 0000000..299ceac --- /dev/null +++ b/assignment 2/iml_assignment2a_solved.ipynb @@ -0,0 +1,250 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Importing the libraries" + ], + "metadata": { + "id": "sCd8w2OwBTLm" + } + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "kWsq3C9zxvlr" + }, + "outputs": [], + "source": [ + "import csv\n", + "import math\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Create the BasicStatistics class" + ], + "metadata": { + "id": "Bw9qskz1BXha" + } + }, + { + "cell_type": "code", + "source": [ + "class BasicStatistics:\n", + " \"\"\"\n", + " Basic statistics class\n", + "\n", + " Attributes:\n", + " dataset: list of numbers\n", + "\n", + " Methods:\n", + " mean: calculates the mean of the dataset\n", + " median: calculates the median of the dataset\n", + " variance: calculates the variance of the dataset\n", + " normalize: normalizes the dataset\n", + " plot: plots the dataset\n", + " \"\"\"\n", + " def __init__(self, dataset):\n", + " \"\"\"\n", + " Constructor for the BasicStatistics class\n", + " :param dataset: list of numbers\n", + " \"\"\"\n", + " self.dataset = dataset\n", + "\n", + " def mean(self):\n", + " \"\"\"\n", + " Calculates the mean of the dataset\n", + " :return: mean of the dataset\n", + " \"\"\"\n", + " return sum(self.dataset) / len(self.dataset)\n", + "\n", + " def median(self):\n", + " \"\"\"\n", + " Calculates the median of the dataset\n", + " :return: median of the dataset\n", + " \"\"\"\n", + " self.dataset.sort()\n", + " if len(self.dataset) % 2 == 0:\n", + " return (self.dataset[len(self.dataset) // 2] + self.dataset[len(self.dataset) // 2 - 1]) / 2\n", + " else:\n", + " return self.dataset[len(self.dataset) // 2]\n", + "\n", + " def variance(self):\n", + " \"\"\"\n", + " Calculates the variance of the dataset\n", + " :return: variance of the dataset\n", + " \"\"\"\n", + " return sum([(x - self.mean()) ** 2 for x in self.dataset]) / len(self.dataset)\n", + "\n", + " def normalize(self):\n", + " \"\"\"\n", + " Normalizes the dataset\n", + " :return normalized dataset\n", + " \"\"\"\n", + " return [(x - self.mean()) / self.variance() for x in self.dataset]\n", + "\n", + " def standard_deviation(self):\n", + " \"\"\"\n", + " Calculates the standard deviation of the dataset\n", + " :return: standard deviation of the dataset\n", + " \"\"\"\n", + " return math.sqrt(self.variance())\n", + "\n", + " def plot(self):\n", + " \"\"\"\n", + " Plots the dataset\n", + " :return:\n", + " \"\"\"\n", + " # get the data\n", + " mean = self.mean()\n", + " median = self.median()\n", + " variance = self.variance()\n", + " std = math.sqrt(variance)\n", + " data_norm = self.normalize()\n", + " # get the number of bins\n", + " nrBins = math.floor(len(self.dataset) / 50)\n", + "\n", + " # set up figure and plot grid\n", + " fig = plt.figure(figsize=(10, 8))\n", + " grid = plt.GridSpec(2, 2)\n", + " ax1 = plt.subplot(grid[:1, :])\n", + " ax2 = plt.subplot(grid[1:, :1])\n", + " ax3 = plt.subplot(grid[1:, 1:])\n", + "\n", + " # set titles\n", + " fig.suptitle('Basic Statistics')\n", + " ax1.set_title('Data Distribution')\n", + " ax2.set_title('Raw Data')\n", + " ax3.set_title('Normalized Data')\n", + "\n", + " # set axes\n", + " ax1.set_xlabel('Values')\n", + " ax1.set_ylabel('Frequency')\n", + " ax2.set_xlabel('Sample')\n", + " ax2.set_ylabel('Value')\n", + " ax3.set_xlabel('Sample')\n", + " ax3.set_ylabel('Standardized Value')\n", + "\n", + " # data plotting\n", + " ax1.hist(data, bins=nrBins, density=True, label='Histogram')\n", + " ax1.vlines(x=mean, ymin=0, ymax=0.3, colors='r', ls='--', label='Mean')\n", + " ax1.vlines(x=median, ymin=0, ymax=0.3, colors='y', ls='--', label='Median')\n", + " ax1.vlines(x=mean + std, ymin=0, ymax=0.3, colors='g', ls='--', label='Standard deviation')\n", + " ax1.vlines(x=mean - std, ymin=0, ymax=0.3, colors='g', ls='--')\n", + " ax1.legend()\n", + " # raw data plotting\n", + " x = [i for i in range(1, len(data) + 1)]\n", + " ax2.scatter(x, data, s=3, label='Data')\n", + " ax2.hlines(y=mean, xmin=0, xmax=len(data), colors='r', ls='--', label='Mean')\n", + " ax2.hlines(y=mean + std, xmin=0, xmax=len(data), colors='g', ls='--', label='Standard deviation')\n", + " ax2.hlines(y=mean - std, xmin=0, xmax=len(data), colors='g', ls='--')\n", + " ax2.legend()\n", + " # normalized data plotting\n", + " ax3.scatter(x, data_norm, s=3, label='Data')\n", + " ax3.hlines(y=0, xmin=0, xmax=len(data), colors='r', ls='--', label='Mean')\n", + " ax3.hlines(y=0 + 1, xmin=0, xmax=len(data), colors='g', ls='--', label='Standard deviation')\n", + " ax3.hlines(y=0 - 1, xmin=0, xmax=len(data), colors='g', ls='--')\n", + " ax3.legend()\n", + "\n", + " plt.show()\n", + " # save the figure\n", + " fig.savefig(\"Basic_Statistics.png\", format=\"png\")\n" + ], + "metadata": { + "id": "cqSJ_htS_04g" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Demonstrate the BasicStatistics class on the data.csv file" + ], + "metadata": { + "id": "xeMDhdMqBd2n" + } + }, + { + "cell_type": "code", + "source": [ + "# define the path to the data file\n", + "path = 'data.csv'\n", + "# open the file and read the data\n", + "with open(path, 'r') as f:\n", + " # create a csv reader\n", + " reader = csv.reader(f)\n", + " # convert the data to a list of floats\n", + " data = list(reader)\n", + " data = [float(x[0]) for x in data]\n", + " # create a BasicStatistics object\n", + " bs = BasicStatistics(data)\n", + " # print the mean, median, and variance\n", + " print(f'Mean: {bs.mean():.2f}')\n", + " print(f'Median: {bs.median():.2f}')\n", + " print(f'Variance: {bs.variance():.2f}')\n", + " # plot the data\n", + " bs.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 606 + }, + "id": "UQVfNd_j_29Z", + "outputId": "e3cab288-537c-4937-b8e0-a7473770400d" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mean: 4.08\n", + "Median: 4.13\n", + "Variance: 4.15\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# New Section" + ], + "metadata": { + "id": "p4TrEpvsABUU" + } + } + ] +} diff --git a/assignment 2/iml_assignment2b_solved.ipynb b/assignment 2/iml_assignment2b_solved.ipynb new file mode 100644 index 0000000..03e3f08 --- /dev/null +++ b/assignment 2/iml_assignment2b_solved.ipynb @@ -0,0 +1,394 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "import numpy as np" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Create a 10x50 matrix with random numbers using numpy" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(10, 50)\n" + ] + } + ], + "source": [ + "x = np.random.rand(10,50)\n", + "# Print the shape of the matrix\n", + "print(x.shape)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.23987495 0.91661312 0.86479877 0.97246676 0.2996044 0.19370428\n", + " 0.38302033 0.45876654 0.23953333 0.88275397 0.39823726 0.68814433\n", + " 0.69320487 0.87894669 0.12043348 0.56381261 0.41057224 0.44619567\n", + " 0.83936425 0.11512131 0.10305665 0.30666838 0.10695437 0.77828681\n", + " 0.26825193 0.88529244 0.13623807 0.85569497 0.56312584 0.83247308\n", + " 0.4950099 0.66125172 0.45603826 0.41389193 0.04471278 0.74099649\n", + " 0.82862858 0.73879875 0.10928491 0.47473116 0.1124304 0.02034965\n", + " 0.3651702 0.24298615 0.02315607 0.63034624 0.86772443 0.45138212\n", + " 0.68984731 0.45618784]\n" + ] + } + ], + "source": [ + "# Ask from the user for a row number and print the row given\n", + "row = int(input(\"Enter a row number: \"))\n", + "print(x[row])\n", + "# Do the same for a column\n", + "col = int(input(\"Enter a column number: \"))\n", + "print(x[:,col])" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Create the following arrays and calculate their dot product\n", + "| 5 | 1 | 3 |\n", + "| 1 | 2 | 1 |\n", + "| 1 | 2 | 1 |\n", + "\n", + "| 1 | 2 | 3 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5 1 3]\n", + " [1 2 1]\n", + " [1 2 1]]\n", + "[[1 2 3]]\n", + "[[16]\n", + " [ 8]\n", + " [ 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", + "print(tmp_array)\n", + "print(tmp_array2)\n", + "print(np.dot(tmp_array,tmp_array2.T))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Given the following matrices calculate their (matrix) multiplication\n", + "A = | 1 | 0 |\n", + "| 0 | 1 |\n", + "\n", + "B = | 4 | 1 |\n", + "| 2 | 2 |\n", + "\n", + "c = | 1 | 2 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[4 1]\n", + " [2 2]]\n", + "[[1]\n", + " [2]]\n" + ] + } + ], + "source": [ + "# A*B\n", + "A = np.array([[1,0],[0,1]])\n", + "B = np.array([[4,1],[2,2]])\n", + "print(np.dot(A,B))\n", + "# A*c\n", + "c = np.array([[1,2]])\n", + "print(np.dot(A,c.T))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Find the third power of this matrix\n", + "\n", + "| 0 | 1 |\n", + "| -1 | 0 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "tmp_array = np.array([[0,1],[-1,0]])\n", + "print(np.linalg.matrix_power(tmp_array,3))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Find the determinant of this matrix\n", + "\n", + "| 1 | 2 |\n", + "| 3 | 4 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.0000000000000004\n" + ] + } + ], + "source": [ + "tmp_array = np.array([[1,2],[3,4]])\n", + "print(np.linalg.det(tmp_array))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Use the functions ‘eye’ and ‘ones’ from numpy to create 4x4 matrices. Find their ranks." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 0. 0. 0.]\n", + " [0. 1. 0. 0.]\n", + " [0. 0. 1. 0.]\n", + " [0. 0. 0. 1.]]\n", + "4\n", + "[[1. 1. 1. 1.]\n", + " [1. 1. 1. 1.]\n", + " [1. 1. 1. 1.]\n", + " [1. 1. 1. 1.]]\n", + "1\n" + ] + } + ], + "source": [ + "tmp_array = np.eye(4)\n", + "print(tmp_array)\n", + "print(np.linalg.matrix_rank(tmp_array))\n", + "tmp_array = np.ones((4,4))\n", + "print(tmp_array)\n", + "print(np.linalg.matrix_rank(tmp_array))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Find the inverse of this matrix\n", + "\n", + "| 2 | 2 | 1 |\n", + "| 1 | 3 | 1 |\n", + "| 1 | 2 | 2 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 13, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.8 -0.4 -0.2]\n", + " [-0.2 0.6 -0.2]\n", + " [-0.2 -0.4 0.8]]\n" + ] + } + ], + "source": [ + "tmp_array = np.array([[2,2,1],[1,3,1],[1,2,2]])\n", + "print(np.linalg.inv(tmp_array))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Find the pseudo inverse of this matrix\n", + "\n", + "| 2 | 8 |\n", + "| 1 | 4 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.02352941 0.01176471]\n", + " [0.09411765 0.04705882]]\n" + ] + } + ], + "source": [ + "tmp_array = np.array([[2,8],[1,4]])\n", + "print(np.linalg.pinv(tmp_array))" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Find the eigenvalues and eigenvectors of this matrix\n", + "\n", + "| 1 | -1 |\n", + "| 1 | 1 |" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 15, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1.+1.j 1.-1.j]\n", + "[[0.70710678+0.j 0.70710678-0.j ]\n", + " [0. -0.70710678j 0. +0.70710678j]]\n" + ] + } + ], + "source": [ + "tmp_array = np.array([[1,-1],[1,1]])\n", + "eigenvalues, eigenvectors = np.linalg.eig(tmp_array)\n", + "print(eigenvalues)\n", + "print(eigenvectors)\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}