{ "cells": [ { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import scipy as scp\n", "import matplotlib.pyplot as plt\n", "import csv" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Multi-Factor Anova Test\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# def get_value(i,j,k,n):\n", "# value = 0\n", "\n", "# match i:\n", "# case \"Yes\": value+= np.random.randint(0,10) *1\n", "# case \"No\": value+= np.random.randint(0,10) *0\n", "\n", "# match j:\n", "# case \"Steel\" : value += np.random.randint(0,10) * 0.5\n", "# case \"Iron\" : value += np.random.randint(0,10) * 0.7\n", "# case \"Aluminum\" : value += np.random.randint(0,10) * 0.1\n", " \n", "# match k:\n", "# case _ : pass\n", " \n", " \n", "\n", "# return round(value,2)\n", " " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# # Generate data\n", "# points_per_group = 10\n", "# I_values = [\"Yes\", \"No\"]\n", "# J_values = [\"Steel\", \"Iron\", \"Aluminum\"]\n", "# K_values = [\"0-10\", \"10-20\", \"20-30\", \"30-40\", \"40-60\", \"60-70\", \"70-80\", \"80-90\", \"90-100\"]\n", "\n", "# data = []\n", "\n", "# for i in I_values:\n", "# for j in J_values:\n", "# for k in K_values:\n", "# for n in range(points_per_group):\n", "# datapoint = {\"Factor 1\":i, \"Factor 2\":j, \"Factor 3\":k, \"Value\":get_value(i,j,k,n)}\n", "# data.append(datapoint)\n", "\n", "# data = np.array(data)\n", "# np.random.shuffle(data)\n", "\n", "# with open(\"C:\\\\Users\\\\mherve\\\\Documents\\\\Courses\\\\Stat\\\\Week13\\\\Data_Week13.csv\", 'w+') as file:\n", "# writer = csv.writer(file, delimiter=',', lineterminator='\\n')\n", "# head = [\"Annealed\", \"Material\", \"Ambient Humidity\", \"Material Score\"]\n", "# writer.writerow(head)\n", "# for point in data: writer.writerow( [point[\"Factor 1\"], point[\"Factor 2\"], point[\"Factor 3\"], point[\"Value\"]])\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this exercise, we practice the multi-factor Anova Test by making the mpartial means table for the following scenario : \n", "An EFPL startup wants to build a component for a satellite, but do not know what material to use. They run test on a series of sample with different properties, and attribute a final score to each sample corresponding to how well the sample fits their project.\n", "The properties of the sample are :\n", "- The Material : can be steel, aluminum or iron\n", "- If the material has been annealed : yes or no\n", "- The humidity of the environment in which the sample is stored : bins of 10 from 0 to 100" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Load the data from the csv file. Remember to check the csv file for yourself to know which data types to expect and which columns or lines to skip.\n", "\n", "Here we are expecting different data types and might need to load different lines seperately, then combine them into one list." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[['No' 'Steel' '70-80']\n", " ['Yes' 'Aluminum' '70-80']\n", " ['No' 'Aluminum' '0-10']\n", " ['Yes' 'Steel' '60-70']\n", " ['No' 'Aluminum' '60-70']]\n", "[2.5 2.6 0.8 3.5 0.4]\n", "(540, 3)\n", "(540,)\n", "(540, 4)\n", "[['No' 'Steel' '70-80' '2.5']\n", " ['Yes' 'Aluminum' '70-80' '2.6']\n", " ['No' 'Aluminum' '0-10' '0.8']\n", " ['Yes' 'Steel' '60-70' '3.5']\n", " ['No' 'Aluminum' '60-70' '0.4']]\n" ] } ], "source": [ "data = np.loadtxt(\"C:\\\\Users\\\\mherve\\\\Documents\\\\Courses\\\\Stat\\\\switch\\\\Exercise12\\\\Data_Week13.csv\", delimiter=',', skiprows=1, usecols=[0,1,2], dtype=str)\n", "print(data[:5])\n", "\n", "value = np.loadtxt(\"C:\\\\Users\\\\mherve\\\\Documents\\\\Courses\\\\Stat\\\\switch\\\\Exercise12\\\\Data_Week13.csv\", delimiter=',', skiprows=1, usecols=[3], dtype=float)\n", "print(value[:5])\n", "\n", "\n", "# data = np.concatenate( (data, value), axis=1)\n", "\n", "print(data.shape)\n", "print(value.shape)\n", "\n", "value = np.reshape( value, (540,1) )\n", "\n", "data = np.concatenate( (data, value), axis=1)\n", "\n", "print(data.shape)\n", "print(data[:5])\n", "\n", "# Note the fact that the values are stored as str." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Make 3 lists with the different *levels* that our *factors* can take. These are categories and have no mathematical meaning." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "Factor1_values = np.array([\"Yes\", \"No\"])\n", "Factor2_values = np.array([\"Steel\", \"Iron\", \"Aluminum\"])\n", "Factor3_values = np.array([\"0-10\", \"10-20\", \"20-30\", \"30-40\", \"40-60\", \"60-70\", \"70-80\", \"80-90\", \"90-100\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Partial Means\n", "Let us now make the partial means table for Factors 1 and 2.\n", "\n", "Start by using a for loop to iterate on the different levels of both factors, and look through the data to find points that fit into this category. Average them and add them to a matrix of appropriate size. Also do the same for the unbiased standard deviation.\n", "\n", "Remember that you cna use *arr[condition]* to filter out values from an array, and the *&* symbol to use multiple conditions. " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[['No' 'Steel' '70-80' '2.5']\n", " ['Yes' 'Aluminum' '70-80' '2.6']\n", " ['No' 'Aluminum' '0-10' '0.8']\n", " ['Yes' 'Steel' '60-70' '3.5']\n", " ['No' 'Aluminum' '60-70' '0.4']\n", " ['Yes' 'Steel' '10-20' '4.5']\n", " ['Yes' 'Aluminum' '40-60' '8.6']\n", " ['No' 'Iron' '10-20' '0.0']\n", " ['Yes' 'Steel' '20-30' '8.0']\n", " ['No' 'Aluminum' '40-60' '0.1']]\n", "\n", "[False True False True False True True False True False]\n", "\n", "[False True False False False False True False False False]\n", "[['Yes' 'Aluminum' '70-80' '2.6']\n", " ['Yes' 'Aluminum' '40-60' '8.6']]\n", "['70-80' '40-60']\n", "\n", "Mean Matrix\n", "[[6.29444444 7.17333333 4.93777778]\n", " [2.15555556 3.11888889 0.41777778]]\n", "\n", "SSE Matrix\n", "[[0.36607839 0.36882511 0.31975169]\n", " [0.15853662 0.20128733 0.02898955]]\n" ] } ], "source": [ "# Comparing 1 and 2\n", "mean_matrix12 = []\n", "ste_matrix12 = []\n", "\n", "\n", "# Practice Browsing : \n", "reduced = data[:10]\n", "print(reduced)\n", "print()\n", "\n", "# One condition\n", "boolean_list = reduced[:,0]=='Yes'\n", "print(boolean_list)\n", "print()\n", "\n", "# Two Condition\n", "boolean_list = (reduced[:,0]=='Yes') & (reduced[:,1]=='Aluminum')\n", "print(boolean_list)\n", "print( reduced[boolean_list] )\n", "print( reduced[boolean_list][:,2] )\n", "print()\n", "\n", "\n", "\n", "# Compare 1 and 2\n", "for i in Factor1_values:\n", " line_mean = []\n", " line_ste = []\n", " for j in Factor2_values:\n", " mask = (data[:,0]==i) & (data[:,1]==j)\n", " ij_values = data[ mask ][:,3].astype(float)\n", " line_mean.append( np.mean(ij_values) )\n", " line_ste.append( np.std(ij_values, ddof=1) / np.sqrt(len(ij_values)) ) \n", " mean_matrix12.append(line_mean)\n", " ste_matrix12.append(line_ste)\n", "\n", "mean_matrix12 = np.array(mean_matrix12)\n", "ste_matrix12 = np.array(ste_matrix12)\n", "\n", "print(\"Mean Matrix\")\n", "print(mean_matrix12)\n", "print()\n", "print(\"SSE Matrix\")\n", "print(ste_matrix12)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use the given function to plot the partial mean table." ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+-----+---------+--------+------------+-------+\n", "| | Steel | Iron | Aluminum | |\n", "+=====+=========+========+============+=======+\n", "| Yes | 6.294 | 7.173 | 4.938 | 6.135 |\n", "+-----+---------+--------+------------+-------+\n", "| No | 2.156 | 3.119 | 0.418 | 1.897 |\n", "+-----+---------+--------+------------+-------+\n", "| | 4.225 | 5.146 | 2.678 | 4.016 |\n", "+-----+---------+--------+------------+-------+\n", "+----------+-------+-------+-------+\n", "| | Yes | No | |\n", "+==========+=======+=======+=======+\n", "| Steel | 6.294 | 2.156 | 4.225 |\n", "+----------+-------+-------+-------+\n", "| Iron | 7.173 | 3.119 | 5.146 |\n", "+----------+-------+-------+-------+\n", "| Aluminum | 4.938 | 0.418 | 2.678 |\n", "+----------+-------+-------+-------+\n", "| | 6.135 | 1.897 | 4.016 |\n", "+----------+-------+-------+-------+\n" ] } ], "source": [ "from tabulate import tabulate\n", "\n", "def plot_mean_matrix(factor1, factor2, matrix, partial_mean1, partial_mean2, total_mean):\n", " \"\"\" Takes the given Factor Levels, group means and partial means and represents them in a table.\n", " factor1 : A list of levels that the first factor can take. size (N,)\n", " factor2 : A list of levels that the second factor can take. size (M,)\n", " matrix : The group means of the given levels. size(N,M)\n", " partial_mean1 : The means over the levels of the first factor size (N,)\n", " partial_mean2 : The means over the levels of the second factor size (M,)\n", " total_mean : The total mean of the table\n", " \"\"\"\n", "\n", "\n", " # Round to get better looking table\n", " matrix = np.round(matrix, 3)\n", " partial_mean1 = np.round(partial_mean1, 3)\n", " partial_mean2 = np.round(partial_mean2, 3)\n", " total_mean = np.round(total_mean, 3)\n", "\n", " # Make sure the size is appropriate\n", " factor1 = np.reshape( factor1, (len(factor1),1))\n", " partial_mean1 = np.reshape( partial_mean1, (len(partial_mean1),1))\n", "\n", " # Main Matrix\n", " mydata = np.concatenate( (factor1, matrix), axis=1)\n", " # Create Header\n", " head = factor2\n", "\n", " # Add partial means\n", " mydata = np.concatenate( (mydata, partial_mean1), axis=1)\n", " mydata = np.concatenate( (mydata, np.reshape(np.append( np.append([\" \"],partial_mean2),[total_mean]), (1,mydata.shape[1])) ) , axis=0)\n", " head = np.append(head, [\" \"] )\n", "\n", " # Display table\n", " print(tabulate(mydata, headers=head, tablefmt=\"grid\"))\n", "\n", "\n", "# See the shape to be clear on which axis to act\n", "Factor1_PartialMeans = np.mean(mean_matrix12, axis=1)\n", "Factor2_PartialMeans = np.mean(mean_matrix12, axis=0)\n", "Total_Mean = np.mean(mean_matrix12)\n", "\n", "plot_mean_matrix(Factor1_values, Factor2_values, mean_matrix12, Factor1_PartialMeans, Factor2_PartialMeans, Total_Mean)\n", "plot_mean_matrix(Factor2_values, Factor1_values, np.transpose(mean_matrix12), Factor2_PartialMeans, Factor1_PartialMeans, Total_Mean)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Represent the different means on a plot with errorbars. The x axis should correspond to the levels of one factor, and multiple plots should represent different values of a second factor." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2,)\n", "[5.45 0.83444444]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "print(Factor1_values.shape)\n", "print(mean_matrix12.mean(axis=1))\n", "\n", "plt.errorbar(Factor1_values, mean_matrix12[:,0], ste_matrix12[:,0], linewidth=1, marker=\"x\", markersize=5, linestyle='-.', label=\"Steel\", )\n", "plt.errorbar(Factor1_values, mean_matrix12[:,1], ste_matrix12[:,1], linewidth=1, marker=\"o\", markersize=5, linestyle='-.', label=\"Iron\")\n", "plt.errorbar(Factor1_values, mean_matrix12[:,2], ste_matrix12[:,2], linewidth=1, marker=\"s\", markersize=5, linestyle='-.', label=\"Aluminum\")\n", "\n", "plt.xlabel(\"Factor 1 Levels\")\n", "plt.ylabel(\"Mean Value\")\n", "plt.legend()\n", "plt.show()\n", "\n", "\n", "# Or \n", "\n", "plt.errorbar(Factor2_values, mean_matrix12[0,:], ste_matrix12[0,:], linewidth=1, marker=\"x\", markersize=5, linestyle='-.', label=\"Yes\", )\n", "plt.errorbar(Factor2_values, mean_matrix12[1,:], ste_matrix12[1,:], linewidth=1, marker=\"o\", markersize=5, linestyle='-.', label=\"No\")\n", "\n", "plt.xlabel(\"Factor 2 Levels\")\n", "plt.ylabel(\"Mean Value\")\n", "plt.legend()\n", "plt.show()\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(Optional)** Compute the partial mean table of Factor 3 with one other factor, using the previous function." ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+-----+--------+---------+---------+---------+---------+---------+---------+---------+----------+-------+\n", "| | 0-10 | 10-20 | 20-30 | 30-40 | 40-60 | 60-70 | 70-80 | 80-90 | 90-100 | |\n", "+=====+========+=========+=========+=========+=========+=========+=========+=========+==========+=======+\n", "| Yes | 6.273 | 5.613 | 5.34 | 5.91 | 6.973 | 6.897 | 6.077 | 6.163 | 5.97 | 6.135 |\n", "+-----+--------+---------+---------+---------+---------+---------+---------+---------+----------+-------+\n", "| No | 2.11 | 1.603 | 1.633 | 2.423 | 1.897 | 1.147 | 2.3 | 1.863 | 2.1 | 1.897 |\n", "+-----+--------+---------+---------+---------+---------+---------+---------+---------+----------+-------+\n", "| | 4.192 | 3.608 | 3.487 | 4.167 | 4.435 | 4.022 | 4.188 | 4.013 | 4.035 | 4.016 |\n", "+-----+--------+---------+---------+---------+---------+---------+---------+---------+----------+-------+\n" ] } ], "source": [ "# Comparing 1 and 3\n", "mean_matrix13 = []\n", "\n", "for i in Factor1_values:\n", " line = []\n", " for j in Factor3_values:\n", " ij_values = data[ (data[:,0]==i) & (data[:,2]==j) ][:,3].astype(float)\n", " group_mean = np.mean( ij_values )\n", " line.append(group_mean)\n", " mean_matrix13.append(line)\n", "\n", "mean_matrix13 = np.array(mean_matrix13)\n", "\n", "Factor1_PartialMeans = np.mean(mean_matrix13, axis=1)\n", "Factor3_PartialMeans = np.mean(mean_matrix13, axis=0)\n", "Total_Mean = np.mean(mean_matrix13)\n", "\n", "\n", "plot_mean_matrix(Factor1_values, Factor3_values, mean_matrix13, Factor1_PartialMeans, Factor3_PartialMeans, Total_Mean)\n", "\n" ] } ], "metadata": { "kernelspec": { "display_name": "base", "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.11.7" } }, "nbformat": 4, "nbformat_minor": 2 }