{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# സാധ്യതയും സ്ഥിതിവിവരശാസ്ത്രവും പരിചയം\n",
    "ഈ നോട്ട്‌ബുക്കിൽ, നാം നേരത്തെ ചർച്ച ചെയ്ത ചില ആശയങ്ങളുമായി കളിച്ചുപോകും. സാധ്യതയും സ്ഥിതിവിവരശാസ്ത്രവും സംബന്ധിച്ച പല ആശയങ്ങളും പൈത്തണിലെ പ്രധാന ഡാറ്റ പ്രോസസ്സിംഗ് ലൈബ്രറിസായ `numpy` ഉം `pandas` ഉം എന്നിവയിൽ മികച്ച രീതിയിൽ പ്രതിനിധീകരിക്കപ്പെട്ടിരിക്കുന്നു.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## റാൻഡം വെരിയബിളുകളും വിതരണങ്ങളും\n",
    "0 മുതൽ 9 വരെയുള്ള യൂണിഫോം വിതരണത്തിൽ നിന്ന് 30 മൂല്യങ്ങളുടെ ഒരു സാമ്പിൾ എളുപ്പത്തിൽ എടുക്കാം. കൂടാതെ ശരാശരിയും വ്യത്യാസവും കണക്കാക്കാം.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = [ random.randint(0,10) for _ in range(30) ]\n",
    "print(f\"Sample: {sample}\")\n",
    "print(f\"Mean = {np.mean(sample)}\")\n",
    "print(f\"Variance = {np.var(sample)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "സാമ്പിളിൽ എത്ര വ്യത്യസ്ത മൂല്യങ്ങൾ ഉണ്ടെന്ന് ദൃശ്യമായി കണക്കാക്കാൻ, നാം **ഹിസ്റ്റോഗ്രാം** ചിത്രീകരിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(sample)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## യഥാർഥ ഡാറ്റ വിശകലനം ചെയ്യൽ\n",
    "\n",
    "യഥാർത്ഥ ലോക ഡാറ്റ വിശകലനം ചെയ്യുമ്പോൾ ശരാശരി (Mean) വീതം (variance) വളരെ പ്രധാനമാണ്. [SOCR MLB Height/Weight Data](http://wiki.stat.ucla.edu/socr/index.php/SOCR_Data_MLB_HeightsWeights) മുതൽ ബേസ്ബോൾ കളിക്കാരുടെ ഡാറ്റ ലോഡ് ചെയ്യാം\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"../../data/SOCR_MLB.tsv\",sep='\\t', header=None, names=['Name','Team','Role','Weight','Height','Age'])\n",
    "df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ഡാറ്റ വിശകലനത്തിനായി നാം ഇവിടെ [**Pandas**](https://pandas.pydata.org/) എന്ന പാക്കേജ് 사용ചെയ്യുന്നു. Pandas സമ്പർക്കിച്ച് Python-ൽ ഡാറ്റ കൈകാര്യം ചെയ്യലിനെക്കുറിച്ച് ഈ കോഴ്സ് പിന്നീട് കൂടുതലായി സംസാരിക്കാം.\n",
    "\n",
    "വയസു, ഉയരം, ഭാരത്തിന്റെ ശരാശരി മൂല്യങ്ങൾ കണക്കാക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[['Age','Height','Weight']].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഇപ്പോൾ ഔരംമാനത്തെക്കുറിച്ച് ശ്രദ്ധ കേന്ദ്രീകരിച്ച് സ്റ്റാൻഡേർഡ് ഡിവിയേഷൻ, വേറിൻസുകൾ കണക്കാക്കാം: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(df['Height'])[:20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = df['Height'].mean()\n",
    "var = df['Height'].var()\n",
    "std = df['Height'].std()\n",
    "print(f\"Mean = {mean}\\nVariance = {var}\\nStandard Deviation = {std}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ശരാശരിയോടൊപ്പം, നടുക്കുമൂല്യവും ക്വാർടൈലുകളും നോക്കുന്നത് ഉചിതമാണ്. അവയെ **ബോക്സ് പ്ലോട്ട്** ഉപയോഗിച്ച് ദൃശ്യവൽക്കരിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,2))\n",
    "plt.boxplot(df['Height'].ffill(), orientation='horizontal', showmeans=True)\n",
    "plt.grid(color='gray', linestyle='dotted')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "നമുക്ക് നമ്മുടെ ഡാറ്റാസറ്റിന്റെ ഉപസമിതികളുടെ ബോക്സ് പ്ലോട്ടുകളും തയ്യാറാക്കാം, ഉദാഹരണത്തിന്, കളിക്കാരുടെ റോളുകൾ പ്രകാരം ഗ്രൂപ്പ് ചെയ്തിട്ടുള്ളവ.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.boxplot(column='Height', by='Role', figsize=(10,8))\n",
    "plt.xticks(rotation='vertical')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **കുറിപ്പു**: ഈ ഡയഗ്രാം സൂചിപ്പിക്കുന്നത്, ശരാശരിയിൽ, ഫസ്റ്റ് ബേസ്മനുകളുടെ ഉയരം സെക്കൻഡ് ബേസ്മനുകളുടെ ഉയരത്തിൽ നിന്ന് കൂടുതലാണെന്നാണ്. പിന്നീട് നാം ഈ അനുഭവസങ്കല്പം കൂടുതല്‍ ഔപചാരികമായി പരീക്ഷിക്കാന്‍ എന്താണ് ചെയ്യേണ്ടത്, കൂടാതെ ഞങ്ങളുടെ ഡാറ്റistatistical പോലെ പ്രസക്തമാണെന്ന് എങ്ങനെ തെളിയിക്കാമെന്നു പഠിക്കും.  \n",
    "\n",
    "പ്രായം, ഉയരം, ഭാരങ്ങൾ എല്ലാം നിരന്തരം അവയവമായ വ്യത്യാസങ്ങളാണ്‌. അവരുടെ വിതരണം എന്തായിരിക്കും എന്ന് നിങ്ങൾക്കു തോന്നുന്നുണ്ടോ? മൂല്യങ്ങളുടെ ഹിസ്റ്റോഗ്രാം വരയ്ക്കുക എന്നത് അറിയാനുള്ള നല്ല മാർഗമാണ്: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Weight'].hist(bins=15, figsize=(10,6))\n",
    "plt.suptitle('Weight distribution of MLB Players')\n",
    "plt.xlabel('Weight')\n",
    "plt.ylabel('Count')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## സാധാരണ വിതരണവും\n",
    "\n",
    "നാം നമ്മുടെ യഥാർത്ഥ ഡേറ്റയുമായുള്ള സമാനമായ ശരാശരി മൂല്യവും വേരിയന്‍സും ഉള്ള ഒരു സാധാരണ വിതരണമുള്ള കൃത്രിമ പരീക്ഷണമുളള ഭാരം സൃഷ്ടിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "generated = np.random.normal(mean, std, 1000)\n",
    "generated[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.hist(generated, bins=15)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.hist(np.random.normal(0,1,50000), bins=300)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "യാഥാർത്ഥ്യത്തിൽ അധികം മൂല്യങ്ങൾ സാധാരണ വിതരണത്തിലാണ് జరిగുന്നത്, അതിനാൽ സാമ്പിൾ ഡാറ്റ ഉണ്ടാക്കാൻ ഒന്നാംവിധത്തിൽ യുണിഫോം റാൻഡം നമ്പർ ജനറേറ്റർ ഉപയോഗിക്കരുത്. `np.random.rand` ഉപയോഗിച്ച് യുണിഫോം വിതരണത്തോടെ ഭാരം ഉണ്ടാക്കാൻ ശ്രമിക്കുമ്പഴുണ്ടാകുന്നന്ന് ഇതാ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wrong_sample = np.random.rand(1000)*2*std+mean-std\n",
    "plt.figure(figsize=(10,6))\n",
    "plt.hist(wrong_sample)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ആത്മവിശ്വാസ ഇടവേളകൾ\n",
    "\n",
    "ഇനി നാം ബേസ്‌ബോൾ കളിക്കാർගේ ഭാരത്തിലും ഉയരത്തിലും ആത്മവിശ്വാസ ഇടവേളകൾ കണക്കാക്കാം. നാം ഈ കോഡ് ഉപയോഗിക്കും [from this stackoverflow discussion](https://stackoverflow.com/questions/15033511/compute-a-confidence-interval-from-sample-data):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "\n",
    "def mean_confidence_interval(data, confidence=0.95):\n",
    "    a = 1.0 * np.array(data)\n",
    "    n = len(a)\n",
    "    m, se = np.mean(a), scipy.stats.sem(a)\n",
    "    h = se * scipy.stats.t.ppf((1 + confidence) / 2., n-1)\n",
    "    return m, h\n",
    "\n",
    "for p in [0.85, 0.9, 0.95]:\n",
    "    m, h = mean_confidence_interval(df['Weight'].ffill(),p)\n",
    "    print(f\"p={p:.2f}, mean = {m:.2f} ± {h:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ഹിപ്പ്‌ഥെസിസ് ടെസ്റ്റിംഗ്\n",
    "\n",
    "നമുക്ക് നമ്മുടെ ബേസ്‌ബോൾ താരങ്ങൾ ഡാറ്റാ സെറ്റിൽ വിവിധ പങ്ക് വഹിക്കുന്നവരെ പരിശോധിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.groupby('Role').agg({ 'Weight' : 'mean', 'Height' : 'mean', 'Age' : 'count'}).rename(columns={ 'Age' : 'Count'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഫസ്റ്റ് ബേസ്മെൻ സെക്കൻഡ് ബേസ്മെനിൽ നിന്ന് ഉയരം കൂടുതലാണെന്ന് ഉള്ള ഉദ്ദേശ്യത്തെ നാം പരീക്ഷിക്കാം. ഇത് കാര്യക্ৰমം പരീക്ഷിക്കാനുള്ള ഏറ്റവും ലളിതമായ മാർഗമാണ് വിശ്വാസ അന്തരീക്ഷങ്ങൾ പരിശോധിക്കുക:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in [0.85,0.9,0.95]:\n",
    "    m1, h1 = mean_confidence_interval(df.loc[df['Role']=='First_Baseman',['Height']],p)\n",
    "    m2, h2 = mean_confidence_interval(df.loc[df['Role']=='Second_Baseman',['Height']],p)\n",
    "    print(f'Conf={p:.2f}, 1st basemen height: {m1-h1[0]:.2f}..{m1+h1[0]:.2f}, 2nd basemen height: {m2-h2[0]:.2f}..{m2+h2[0]:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഇടവേളകൾ പരസ്പരം മുഴുങ്ങുന്നില്ലെന്ന് നാം കാണാൻ കഴിയും.\n",
    "\n",
    "തിയറിയെ തെളിയിക്കാൻ കണക്കിലെടുക്കേണ്ടതിലുള്ള കൂടുതൽ ശരിയായ ഒരു രീതിയാണ് **സ്റ്റുഡന്റ് t-ടെസ്റ്റ്** ഉപയോഗിക്കുക:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "\n",
    "tval, pval = ttest_ind(df.loc[df['Role']=='First_Baseman',['Height']], df.loc[df['Role']=='Second_Baseman',['Height']],equal_var=False)\n",
    "print(f\"T-value = {tval[0]:.2f}\\nP-value: {pval[0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ttest_ind` ഫംഗ്ഷനിലൂടെ മടങ്ങിവരുന്ന രണ്ട് മൂല്യങ്ങൾ:\n",
    "* p-വാല്യു രണ്ട് വിതരണമങ്ങളുടെയും ശരാശരി ഒരുപോലെയെന്നാണ് കാണിക്കുന്ന സാദ്ധ്യതയായി പരിഗണിക്കാം. നമ്മുടെ കേസിൽ, ഇത് വളരെ താഴ്ന്നതാണ്, അതായത് ആദ്യ baseman-ുകൾക്ക് ഉയരമുള്ളവരാണ് എന്ന് ശക്തമായ തെളിവുകൾ ഉണ്ടായെന്നു സൂചിപ്പിക്കുന്നു.\n",
    "* t-വാല്യു എന്നു പറഞ്ഞാൽ t-ടെസ്റ്റിൽ ഉപയോഗിക്കുന്ന സാധാരണപ്പെടുത്തിയ ശരാശരി വ്യത്യാസത്തിന്റെ ഇടത്തരം മൂല്യമാണ്, ഇത് നിശ്ചിത വിശ്വാസ മൂല്യത്തിനുള്ള ത്രെഷോൾഡ് മൂല്യവുമായി താരതമ്യം ചെയ്യപ്പെടുന്നു.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## സെൻട്രൽ ലിമിറ്റ് തെറിയം ഉപയോഗിച്ച് ഒരു നോർമൽ വിതരണം സിമുലേറ്റ് ചെയ്യുക\n",
    "\n",
    "Pythonല്‍ ഉള്ള pseudo-random ജനറേറ്റർ ഞങ്ങൾക്ക് ഒരേസമയം समानമായ (uniform) വിതരണം നൽകാൻ മാത്രമേ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളൂ. നാം ഒരു നോർമൽ വിതരണത്തിന് ജനറേറ്റർ സൃഷ്ടിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, സെൻട്രൽ ലിമിറ്റ് തെറിയം ഉപയോഗിക്കാം. ഒരു നോർമലായി വിതരണമുള്ള മൂല്യമാണ് നേടേണ്ടത് എങ്കിൽ നാം uniform-ജനിത പോമായ ഒരു സാമ്പിളിന്റെ ശരാശരി കണക്കുകൂട്ടും.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normal_random(sample_size=100):\n",
    "    sample = [random.uniform(0,1) for _ in range(sample_size) ]\n",
    "    return sum(sample)/sample_size\n",
    "\n",
    "sample = [normal_random() for _ in range(100)]\n",
    "plt.figure(figsize=(10,6))\n",
    "plt.hist(sample)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## സഹബന്ധവും ദുര്ധടക ബേസ്ബോൾ കോർപ്പറേഷനും\n",
    "\n",
    "സഹബന്ധം (Correlation) ഡാറ്റാ ക്രമങ്ങളുടെ തമ്മിലുള്ള ബന്ധങ്ങൾ കണ്ടെത്താൻ സഹായിക്കുന്നു. നമ്മുടെ കളിപ്പാട്ട ഉദാഹരണത്തിൽ, ഒരു ദുര്ധടക ബേസ്ബോൾ കോർപ്പറേഷൻ ഉണ്ട് എന്നു നമുക്ക് കരുതാം, അത് കളിക്കാർക്ക് അവരുടെ ഉയരത്തിന് അനുസൃതമായി പ്രതിഫലം നൽകുന്നു - കളിക്കാരി എത്ര ഉയരം കൂടിയവനാണെങ്കിൽ, അദ്ദേഹത്തിന് ലഭിക്കുന്ന പണം അത്രമേൽ കൂടും. അടിസ്ഥാന ശമ്പളം $1000 ആണ് എന്നു കരുതുക, കൂടാതെ ഉയരത്തിനെ ആശ്രയിച്ചുള്ള $0 മുതൽ $100 വരെ ബോണസും ഉണ്ട്. നമ്മൾ MLB-യിലെ യഥാർത്ഥ കളിക്കാരെ എടുത്ത് അവരുടെ kugira ആയ ശമ്പളങ്ങൾ കണക്കാക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "heights = df['Height'].ffill()\n",
    "salaries = 1000+(heights-heights.min())/(heights.max()-heights.mean())*100\n",
    "print(list(zip(heights, salaries))[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "നമുക്ക് ഇപ്പോൾ ആ ക്രമങ്ങളുടെ സഹവ്യത്യാസവും സഹസംബന്ധവും കണക്കാക്കാം. `np.cov` നമുക്ക്所谓的 **സഹവ്യത്യാസ മാട്രിക്‌സ്** നൽകും, ഇത് ഒന്നിലധികം ചാരങ്ങളിലേക്കുള്ള സഹവ്യത്യാസത്തിന്റെ വിപുലീകരണമാണ്. സഹവ്യത്യാസ മാട്രിക്‌സ് $M$ യുടെ ഘടകം $M_{ij}$ ഇൻപുട്ട് ചാരങ്ങൾ $X_i$ ഉം $X_j$ ഉം തമ്മിലുള്ള സഹസംബന്ധമാണ്, കൂടാതെ തൊണ്ണൂറിൽ പടിയുള്ള മൂല്യങ്ങൾ $M_{ii}$ $X_i$ ന്റെ വ്യത്യാസമാണ്. അതുപോലെ, `np.corrcoef` നമുക്ക് **സഹസംബന്ധ മാട്രിക്‌സ്** നൽകും.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Covariance matrix:\\n{np.cov(heights, salaries)}\")\n",
    "print(f\"Covariance = {np.cov(heights, salaries)[0,1]}\")\n",
    "print(f\"Correlation = {np.corrcoef(heights, salaries)[0,1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഒരു സഹബന്ധം 1-ന് തുല്യമാണ് എന്നത് രണ്ട് ചാരങ്ങളുടെ মাজയിൽ ശക്തമായ **രേഖീയ ബന്ധം** ഉള്ളതായിയാണ് അർത്ഥമാക്കുന്നത്. ഒരു മൂല്യം മറ്റൊന്നിനെ എതിരെ രേഖയായുള്ള ബന്ധം ഞങ്ങൾ രൂക്ഷമായി കാണാൻ കഴിയും:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.scatter(heights,salaries)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ബന്ധം നേരിയല്ലെങ്കിൽ എന്താകും സംഭവിക്കുന്നത് നോക്കാം. നമ്മുടെകമ്പനിക്ക് ഉയരവും ശമ്പളവും തമ്മിലുള്ള വ്യക്തമായ നേരിയ ആശ്രിതത്വം മറച്ചുവെക്കണമായിട്ടുള്ളതും, സമവാക്യത്തിൽ `sin` പോലുള്ള കുറച്ച് നേരിയതല്ലാത്തത്വം പരിചയപ്പെടുത്തുകയായിരുന്നുവെന്നും കരുതുക:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "salaries = 1000+np.sin((heights-heights.min())/(heights.max()-heights.mean()))*100\n",
    "print(f\"Correlation = {np.corrcoef(heights, salaries)[0,1]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഈ കേസിൽ, കോറിലേഷൻ കുറേക്കൂടി ചെറുതായിരിക്കും, എന്നാൽ അത് ഇന്നും വളരെ ഉയർന്നതാണ്. ഇപ്പോൾ, ബന്ധം കൂടുതൽ വ്യക്തമല്ലാതാക്കാൻ, ശമ്പളത്തിന് ഒരു ഏതേവർകൽ വ്യത്യാസം ചേർത്തുകൊണ്ട് കുറച്ച് അധിക അനിശ്ചിതത്വം ചേർക്കാൻ ആഗ്രഹിക്കാം. എന്ത് സംഭവിക്കുമോ എന്ന് നോക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "salaries = 1000+np.sin((heights-heights.min())/(heights.max()-heights.mean()))*100+np.random.random(size=len(heights))*20-10\n",
    "print(f\"Correlation = {np.corrcoef(heights, salaries)[0,1]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.scatter(heights, salaries)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> കിണറുപോലെയുള്ള വൃത്തങ്ങൾ ഇതുപോലെ നിത്യരേഖകളായി ഒരു നിരകളായി മാറുന്നത് നിങ്ങൾക്കറിയാമോ?\n",
    "\n",
    "ശമ്പളം എന്ന കല്പിതമായ ആശയവും വീതി എന്ന നിരീക്ഷിച്ച വ്യത്യാസവും തമ്മിലുള്ള സഹബന്ധം നാം കണ്ടിട്ടുണ്ട്. വീതി, ഭാരം എന്നിവരിൽ രണ്ടും തമ്മിൽ സഹബന്ധമുണ്ടോ എന്ന് നമുക്ക് പരിശോധിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.corrcoef(df['Height'].ffill(),df['Weight'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ദുർഭാഗ്യവശാൽ, нам്ാൻ ഫലം ലഭിച്ചില്ല - ചില അസാധാരണമായ `nan` മൂല്യങ്ങൾ മാത്രമാണ് ഉണ്ടായത്. ഞങ്ങളുടെ സീരീസിലെ ചില മൂല്യങ്ങൾ നിർവചിക്കപ്പെടാത്തവയാണ്, `nan` ആയി പ്രതിനിധീകരിച്ചിരിക്കുന്നത്, ഇതാണ് പ്രവർത്തിയുടെ ഫലവും നിർവചിക്കപ്പെടാത്തതാകുന്നതിന്റെ കാരണം. מטרിക്സ് കണ്ടാൽ `Weight` ആണ് പ്രശ്നമുണ്ടാക്കുന്ന കോളം, കാരണം `Height` മൂല്യങ്ങൾക്കിടയിലെ സ്വയം-സംബന്ധം കണക്കാക്കിയിട്ടുണ്ട്.\n",
    "\n",
    "> ഈ ഉദാഹരണം **ഡാറ്റാ തയ്യാറെടുപ്പിന്റെ**യും **ശുചിത്വത്തിന്റെ**വഴി പ്രാധാന്യം കാണിക്കുന്നു. ശരിയായ ഡാറ്റ കൂടാതെ നാം ഒന്നും കണക്കാക്കാൻ കഴിയില്ല.\n",
    "\n",
    "നഷ്ടമായ മൂല്യങ്ങൾ പൂരിപ്പിക്കാൻ `fillna` രീതി ഉപയോഗിക്കാം, പിന്നീട് സഹബന്ധം കണക്കാക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.corrcoef(df['Height'].ffill(), df['Weight'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ചേർത്ത് കണക്കാക്കുമ്പോൾ വിശ്വസിക്കാവുന്നൊരു ബന്ധമുണ്ട്, പക്ഷെ നമ്മുടെ കൃത്രിമ ഉദാഹരണത്തിലെത്ര ശക്തമല്ല. സത്യത്തിൽ, ഒരു മൂല്യത്തിന്റെ സ്‌കാറ്റർ പ്ലോട്ട് മറ്റൊന്നിനോട് താരതമ്യം ചെയ്താൽ, ബന്ധം കുറെയധികം വ്യക്തമായി കാണുന്നതായിരിക്കും:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "plt.scatter(df['Weight'],df['Height'])\n",
    "plt.xlabel('Weight')\n",
    "plt.ylabel('Height')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## നിഗമനം\n",
    "\n",
    "ഈ നോട്ട്ബുക്ക് ഉപയോഗിച്ച് നമുക്ക് ഡാറ്റയിൽ അടിസ്ഥാന പ്രവർത്തനങ്ങൾ നിർവ്വഹിച്ച് സ്റ്റാറ്റിസ്റ്റിക്കൽ ഫംഗ്ഷനുകൾ എങ്ങനെ കണക്കാക്കാമെന്നത് പഠിച്ചു. ചില ഹിപ്പോത്തസുകൾ തെളിയിക്കാൻ ഗണിതം, സ്ഥിതിവിവരശസ്ത്രത്തിന്റെ തർക്കസഹായക ഉപകരണങ്ങൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നും, ഒരു ഡാറ്റാ സാമ്പിള്‍ ലഭിച്ച വെറും വ്യത്യസ്ത ചാരിതാർത്ഥ്യങ്ങൾക്കായി വിശ്വാസ ഇടവേളകൾ എങ്ങനെ കണക്കാക്കാമെന്നും ഇപ്പോൾ നമുക്ക് അറിയാം.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**അറിയിപ്പ്**:\nഈ രേഖ AI പരിഭാഷാ സേവനം [Co-op Translator](https://github.com/Azure/co-op-translator) ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്കായി ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള അസൽ രേഖയാണ് പ്രാമാണികമായ ഉറവിടമായി പരിഗണിക്കേണ്ടത്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ച് ഉണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "86193a1ab0ba47eac1c69c1756090baa3b420b3eea7d4aafab8b85f8b312f0c5"
  },
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}