{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ಪ್ರಾಬಬಿಲಿಟಿ ಮತ್ತು ಸಂಖ್ಯಾಶಾಸ್ತ್ರಕ್ಕೆ ಪರಿಚಯ\n",
    "ಈ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ, ನಾವು ಹಿಂದಿನಂತಾಗಿ ಚರ್ಚಿಸಿರುವ ಕೆಲವು ಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಆಟ ಆಡೋಣ. ಪ್ರಾಬಬಿಲಿಟಿ ಮತ್ತು ಸಂಖ್ಯಾಶಾಸ್ತ್ರದಿಂದ ನಗರಿಸಿದ ಹಲವು ಕಲ್ಪನೆಗಳು Python ನಲ್ಲಿ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ ಪ್ರಮುಖ ಲೈಬ್ರರಿಗಳಾದ `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",
    "ಸರಾಸರಿ ಮತ್ತು ವೈಚಿತ್ರ್ಯವು ನಿಜವಾದ ಜಗತ್ತಿನ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸುವಾಗ ತುಂಬಾ ಪ್ರಮುಖವಾದವು. [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": [
    "> **ಇತ್ಯಾದಿ**: ಈ ರೂಪರೇಖೆ ಸೂಚಿಸುತ್ತದೆ, ಸರಾಸರಿ olarak, ಮೊದಲ ಬ್ಯಾಗ್‌ಮ್ಯಾನ್‌ಗಳ ಎತ್ತರ ಎರಡನೇ ಬ್ಯಾಗ್‌ಮ್ಯಾನ್‌ಗಳ ಎತ್ತರಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿವೆ. ನಂತರ ನಾವು ಈ ಊಹೆಯನ್ನು ಯಥಾರ್ಥವಾಗಿ ಪರೀಕ್ಷಿಸುವುದನ್ನು ಕಲಿಯುವೆವು, ಮತ್ತು ನಮ್ಮ ಡೇಟಾ ವೈಜ್ಞಾನಿಕವಾಗಿ ಮಹತ್ವಪೂರ್ಣವಾಗಿದೆ ಎಂದು ತೋರಿಸುವ ಮಾರ್ಗವನ್ನು ತಿಳಿಯುವೆವು.  \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",
    "ಈಗ ನಾವು ಬೇಸ್‌ಬಾಲ್ ಆಟಗಾರರ ತೂಕ ಮತ್ತು ಎತ್ತರಗಳ ವಿಶ್ವಾಸ ಇಂಟರ್ವಾಲ್ಗಳನ್ನು ಲೆಕ್ಕಹಾಕೋಣ. ನಾವು [ಈ stackoverflow ಚರ್ಚೆಯಿಂದ] (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",
    "ನಾವೆಲ್ಲ naše ಬ್ಯಾಸ್ಬಾಲ್ ಆಟಗಾರರ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ವಿಭಿನ್ನ ಪಾತ್ರಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:\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-ಮೌಲ್ಯವನ್ನು ಎರಡು ವಿತರಣೆಯು ಒಂದೇ ಸರಾಸರಿ ಹೊಂದಿರುವ ಸಂಭವನೀಯತೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ಅದು ಬಹಳ ಕಡಿಮೆ, ಅಂದರೆ ಮೊದಲ ಬ್ಯಾಡ್ಮನ್ ಗಳು ಉದ್ದವೇ ಹೆಚ್ಚು ಎಂಬ ಬಲವಾದ ಸಾಕ್ಷ್ಯಗಳಿವೆ.\n",
    "* t-ಮೌಲ್ಯವು ಸಾಮಾನ್ಯೀಕೃತ ಸರಾಸರಿ ವ್ಯತ್ಯಾಸದ ಮಧ್ಯದ ಮೌಲ್ಯವಾಗಿದೆ, ಇದು t-ಪರೀಕ್ಷೆಯಲ್ಲಿ ಬಳಸದಾಗುತ್ತದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ವಿಶ್ವಾಸ ಮಟ್ಟಕ್ಕೆ ವಿರುದ್ಧ ತೀಚಿದ ಮೌಲ್ಯ ಹೋಲಿಸಿ ಪರಿಶೀಲನೆ ಮಾಡಲಾಗುತ್ತದೆ.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ಕೇಂದ್ರ ಸೀಮಾ ಸಿದ್ಧಾಂತದೊಂದಿಗೆ ಸಾಮಾನ್ಯ ವಿತರಣೆಯನ್ನು ನಕಲಿಸುವುದು\n",
    "\n",
    "Python ನ ಪ್ಸ್‌ಯುಡೋ-ರ್ಯಾಂಡಮ್ ಜನರೇಟರ್ ನಮಗೆ ಸರ್ವત્ર ಸಮವ್ಯಾಪ್ತಿ ವಿತರಣೆಯನ್ನು ನೀಡುವುದಕ್ಕೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ನಾವು ಸಾಮಾನ್ಯ ವಿತರಣೆಗೆ ಜನರೇಟರ್ ರಚಿಸಲು ಬಯಸಿದರೆ, ನಾವು ಕೇಂದ್ರ ಸೀಮಾ ಸಿದ್ಧಾಂತವನ್ನು ಬಳಸಬಹುದು. ಸಾಮಾನ್ಯ ವಿತರಣೆಯ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ನಾವು ಸರ್ವತ್ರ ಸಮವ್ಯಾಪ್ತಿದಾಗಿದೆ ವಿವಿಧ ಮಾದರಿಯ ಸರಾಸರಿಯನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತೇವೆ.\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",
    "ಸಮಂಬಂಧ ನಮಗೆ ಡೇಟಾ ಸರಣಿಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ಕಂಡುಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಮ್ಮ ಆಟದ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದೊಂದು ದುಷ್ಟ ಬೇಟ್ಸ್‌ಬಾಲ್ ಕಾರ್ಪೊರೇಶನ್ ಇದೆ ಎಂದು ಭಾವಿಸೋಣ, ಅದು ತನ್ನ ಆಟಗಾರರನ್ನು ಅವರ ಎತ್ತರದ ಪ್ರಕಾರ ವೇತನ ನೀಡುತ್ತದೆ - ಆಟಗಾರ ಎತ್ತರವಾಗಿದ್ದರೆ, ಅವನು/ಅವಳು ಹೆಚ್ಚು ಹಣ ಪಡೆಯುತ್ತಾರೆ. ಧಾರಣೆ ಮಾಡಿ ಮೂಲ ವೇತನ $1000, ಮತ್ತು ಎತ್ತರದ ಆಧಾರದ ಮೇಲೆ $0 ರಿಂದ $100 ರವರೆಗೆ ಹೆಚ್ಚುವರಿ ಬೋನಸ್ ಇದೆ. ನಾವು MLB ನ ವಾಸ್ತವಿಕ ಆಟಗಾರರನ್ನು ತೆಗೆದು ಅವರ ಕಾಲ್ಪನಿಕ ವೇತನಗಳನ್ನು ಲెక్కಿಸುತ್ತೇವೆ:\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` ಎಂಬಂತೆ ಕೆಲವು ರೇಖೀಯತೆಯಿಲ್ಲದಿಕೆ (non-linearity) ಪರಿಚಯಿಸಿದೆ ಎಂದು ಊಹಿಸೋಣ:\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": [
    "## ನಿರupeಕ್ಷೆ\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
}