Data-Science-For-Beginners/translations/ml/1-Introduction/01-defining-data-science/notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ചലഞ്ച്: ഡാറ്റാ സയൻസ് സംബന്ധിച്ച എൻവ്യവസായം വിശകലനം\n",
    "\n",
    "ഈ ഉദാഹരണത്തിൽ, പരമ്പരാഗത ഡാറ്റാ സയൻസ് പ്രക്രിയയുടെ എല്ലാ ഘട്ടങ്ങളും ഉൾക്കൊള്ളുന്ന ഒരു ലളിതമായ വ്യായാമം ചെയ്യാം. നിങ്ങൾക്ക് കോഡ് എഴുതേണ്ടതില്ല, താഴെയുള്ള സെല്ലുകൾ ക്ലിക്ക് ചെയ്ത് അവ പ്രവർത്തിപ്പിച്ച് ഫലം കാണാം. ഒരു ചലഞ്ചായി, നിങ്ങൾക്ക് ഈ കോഡ് വ്യത്യസ്ത ഡാറ്റ ഉപയോഗിച്ച് പരീക്ഷിക്കാൻ പ്രോത്സാഹനമുണ്ട്.\n",
    "\n",
    "## ലക്ഷ്യം\n",
    "\n",
    "ഈ പാഠത്തിൽ, നാം ഡാറ്റാ സയൻസുമായി ബന്ധപ്പെട്ട വ്യത്യസ്ത ആശയങ്ങളെക്കുറിച്ച് ചർച്ച ചെയ്തു പറ്റുന്നു. കുറച്ചധികം **ടെക്സ്റ്റ് മൈനിംഗ്** ചെയ്യുന്നതിലൂടെ കൂടുതൽ ബന്ധപ്പെട്ട ആശയങ്ങൾ കണ്ടെത്താൻ ശ്രമിയ്ക്കാം. നാം ഡാറ്റാ സയൻസിനെക്കുറിച്ചുള്ള ഒരു ടെക്സ്റ്റിൽ നിന്നാരംഭിച്ച് അതിൽ നിന്നുള്ള പ്രധാനവാക്കുകൾ എടുക്കും, ശേഷം ഫലം ദൃശ്യമാക്കാൻ ശ്രമിക്കാം.\n",
    "\n",
    "ടെക്സ്റ്റായി, ഞാൻ വിക്കിപീഡിയയിലെ ഡാറ്റാ സയൻസ് പേജ് ഉപയോഗിക്കും:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://en.wikipedia.org/wiki/Data_science'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ഘട്ടം 1: ഡാറ്റ നേടല്‍\n",
    "\n",
    "ഓരോ ഡാറ്റ സയന്‍സ് പ്രക്രിയയിലും ആദ്യത്തെ ഘട്ടം ഡാറ്റ നേടുകയാണ്. അതിന് `requests` ലൈബ്രറി ഉപയോഗിക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "# Define a custom header.\n",
    "headers = {\n",
    "    'User-Agent': 'DataScienceChallenge/1.0 (myemail@gmail.com)'\n",
    "}\n",
    "\n",
    "# Pass the headers into the get request\n",
    "response = requests.get(url, headers=headers)\n",
    "\n",
    "if response.status_code == 200:\n",
    "    text = response.content.decode('utf-8')\n",
    "    print(text[:1000])\n",
    "else:\n",
    "    print(f\"Error: {response.status_code}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ഘട്ടം 2: ഡാറ്റ പരിവർത്തനം ചെയ്യൽ\n",
    "\n",
    "പ്രോസസ്സ് ചെയ്യാൻ അനുയോജ്യമായ ആകൃതിയിലേക്ക് ഡാറ്റ മാറാനുള്ള അടുത്ത ഘട്ടമാണ്. നമ്മുടെ കേസിൽ, നാം പേജ് നിന്നുള്ള HTML ഉറവിട കോഡ് ഡൗൺലോഡ് ചെയ്തു, plain text ആക്കി മാറ്റേണ്ടതാണ്.\n",
    "\n",
    "ഈ പ്രവർത്തി ചെയ്യാനുള്ള നിരവധി മാർഗങ്ങളുണ്ട്. HTML പാഴ്സിംഗിനായി പ്രശസ്തമായ Python ലൈബ്രറി [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/) നാം ഉപയോഗിക്കും. BeautifulSoup നമുക്ക് പ്രത്യേക HTML ഘടകങ്ങളെ ലക്ഷ്യമാക്കി, Wikipedia യുടെ പ്രധാന ലേഖന ഉള്ളടക്കം മാറ്റിവെക്കാനും ചില നവിഗേഷൻ മെനുക്കൾ, സൈഡ്ബാറുകൾ, ഫൂട്ടറുകൾ, മറ്റ് അനാവശ്യ ഉള്ളടക്കങ്ങൾ കുറയ്ക്കാനും സഹായിക്കുന്നു (എങ്കിലും ചില ബോയിലർപ്ലേറ്റ് ടെക്സ്റ്റ് ഒതുങ്ങി ബാക്കി ഉണ്ടാകാം).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ആദ്യം, HTML പാഴ്സ് ചെയ്യുന്നതിനായി BeautifulSoup ലൈബ്രറി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install beautifulsoup4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bs4 import BeautifulSoup\n",
    "\n",
    "# Parse the HTML content\n",
    "soup = BeautifulSoup(text, 'html.parser')\n",
    "\n",
    "# Extract only the main article content from Wikipedia\n",
    "# Wikipedia uses 'mw-parser-output' class for the main article content\n",
    "content = soup.find('div', class_='mw-parser-output')\n",
    "\n",
    "def clean_wikipedia_content(content_node):\n",
    "    \"\"\"Remove common non-article elements from a Wikipedia content node.\"\"\"\n",
    "    # Strip jump links, navboxes, reference lists/superscripts, edit sections, TOC, sidebars, etc.\n",
    "    selectors = [\n",
    "        '.mw-jump-link',\n",
    "        '.navbox',\n",
    "        '.reflist',\n",
    "        'sup.reference',\n",
    "        '.mw-editsection',\n",
    "        '.hatnote',\n",
    "        '.metadata',\n",
    "        '.infobox',\n",
    "        '#toc',\n",
    "        '.toc',\n",
    "        '.sidebar',\n",
    "    ]\n",
    "    for selector in selectors:\n",
    "        for el in content_node.select(selector):\n",
    "            el.decompose()\n",
    "\n",
    "if content:\n",
    "    # Clean the content node to better approximate article text only.\n",
    "    clean_wikipedia_content(content)\n",
    "    text = content.get_text(separator=' ', strip=True)\n",
    "    print(text[:1000])\n",
    "else:\n",
    "    print(\"Could not find main content. Using full page text.\")\n",
    "    text = soup.get_text(separator=' ', strip=True)\n",
    "    print(text[:1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ഘട്ടം 3:洞察ങ്ങള്‍ നേടല്‍\n",
    "\n",
    "ഏറ്റവും പ്രധാനപ്പെട്ട ഘട്ടം നമ്മുടെ ഡാറ്റയിൽ നിന്നു洞察ങ്ങള്‍ രാത്രി എടുക്കാനാകുന്ന ഒരു രൂപത്തിലേക്ക് മാറുകയാണു്. നമ്മുടെകേസിൽ, നാം വാക്കുകളുടെ പ്രധാനപ്പെട്ടവ കണ്ടെത്താൻ ആഗ്രഹിക്കുന്നു, ഏത് വാക്കുകൾ കൂടുതലായി അര്‍ഥമുള്ളവയാണെന്ന് കാണാനാണ്.\n",
    "\n",
    "നാം Python ലൈബ്രറിയായ [RAKE](https://github.com/aneesha/RAKE) ഉപയോഗിച്ച് വാക്കുകൾ തിരഞ്ഞെടുക്കും. ആദ്യം, ലൈബ്രറി ചുമ്ലമായില്ലെങ്കിൽ ഇത് ഇഷ്ടപ്പെടുക:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install nlp_rake"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "പ്രാഥമിക പ്രവർത്തനക്ഷമത `Rake` objects ൽ നിന്ന് ലഭ്യമാണ്, ഞങ്ങൾ ചില പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് അത് ആധികാരികമാക്കാവുന്നതാണ്. നമ്മുടെ കേസിൽ, ഒരു കീവേഡ് കുറഞ്ഞത് 5 അക്ഷരങ്ങൾ പെട്ടിരിക്കണം, ഒരു കീവേഡിന്റെ രേഖയിൽ കുറഞ്ഞത് 3 തവണ വരികയും, ഒരു കീവേഡിൽ പരമാവധി 2 വാക്കുകൾ ഉണ്ടാകണം എന്ന് നമുക്ക് സജ്ജമാക്കാം. മറ്റ് മൂല്യങ്ങളുമായി പരീക്ഷിക്കാൻ മടിക്കേണ്ട, ഫലങ്ങൾ ശ്രദ്ധിക്കുക.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nlp_rake\n",
    "extractor = nlp_rake.Rake(max_words=2,min_freq=3,min_chars=5)\n",
    "res = extractor.apply(text)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "പദങ്ങളുടെ ഒരു പട്ടിക അനുബന്ധമായ പ്രാധാന്യ ഡിഗ്രിയോടുകൂടി ലഭിച്ചു. നിങ്ങൾ കാണുന്നത് പോലെ, മെഷീൻ ലേണിംഗ്, ബിഗ് ഡാറ്റ തുടങ്ങിയ ഏറ്റവും പ്രാധാന്യമുള്ള ശാസനകൾ പട്ടികയിലെ മുകളിലെ സ്ഥാനങ്ങളിൽ നിലവിലുണ്ട്.\n",
    "\n",
    "## ഘട്ടം 4: ഫലത്തിന്റെ ദൃശ്യവൽക്കരണം\n",
    "\n",
    "ആളുകൾക്ക് ഡാറ്റ ദൃശ്യരൂപത്തിൽ ഏറ്റവും നല്ല രീതിയിൽ വ്യാഖ്യാനം ചെയ്യാനാകും. അതിനാൽ ചില洞നീക്ഷണങ്ങൾ വരുത്തുന്നതിന് ഡാറ്റ ദൃശ്യവൽക്കരിക്കുന്നത് സാധാരണയായി മനസ്സിലാക്കാവുന്നതാണ്. പൈഥണിലെ `matplotlib` ലൈബ്രറി ഉപയോഗിച്ച് പ്രാധാന്യമനുസരിച്ച് കീവേഡുകളുടെ ലളിതമായ വിതരണം പ്ലോട്ട് ചെയ്യാൻ സാധിക്കും:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot(pair_list):\n",
    "    k,v = zip(*pair_list)\n",
    "    plt.bar(range(len(k)),v)\n",
    "    plt.xticks(range(len(k)),k,rotation='vertical')\n",
    "    plt.show()\n",
    "\n",
    "plot(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "എന്നിരുന്നാലും, വാക്കുകളുടെ ആവർത്തനങ്ങൾ പ്രകടിപ്പിക്കാനൊരു മികച്ച മാർഗം ഇപ്പോഴും ഉണ്ട് - **Word Cloud** ഉപയോഗിച്ച്. നമുക്ക് കീവർഡ് ലിസ്റ്റിൽ നിന്നുള്ള വാക്കുകളുടെ പ്രഭാവം കാണിക്കാൻ മറ്റൊരു ലൈബ്രറി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!{sys.executable} -m pip install wordcloud"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`WordCloud` ഒബ്ജക്ട് അതിന്റെ തീവ്രതകളുള്ള പൂർവ ഗണന ചെയ്‌ത വാക്കുകളുടെ ലിസ്റ്റോ, അല്ലെങ്കിൽ അസൽ പാഠമോ എടുത്ത് കഴിഞ്ഞ്, ഒരു ചിത്രം മടക്കി നൽകുന്നതിന് ഉത്തരവാദിയാണ്, അത് പിന്നീട് `matplotlib` ഉപയോഗിച്ച് പ്രദർശിപ്പിക്കാവുന്നതാണ്:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from wordcloud import WordCloud\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "wc = WordCloud(background_color='white',width=800,height=600)\n",
    "plt.figure(figsize=(15,7))\n",
    "plt.imshow(wc.generate_from_frequencies({ k:v for k,v in res }))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "അസൽ ടെക്സ്റ്റും `WordCloud`-ലേക്ക് പാസ്സാക്കാം - ഒരേ പോലുള്ള ഫലം ലഭ്യമാകുമോ നോക്കാം:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,7))\n",
    "plt.imshow(wc.generate(text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wc.generate(text).to_file('images/ds_wordcloud.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ഇപ്പോൾ വേഡ് ക്ലൗഡ് കൂടുതൽ പ്രഭാവവതിയാണ് എന്ന് നിങ്ങൾക്ക് കാണാം, എന്നാൽ അതിലും കൂടിയ ശബ്ദം (ഉദാ. `Retrieved on` പോലുള്ള ബന്ധപ്പെട്ടിട്ടില്ലാത്ത വാക്കുകൾ) അടങ്ങിയിരിക്കുന്നു. കൂടാതെ, *data scientist* അല്ലെങ്കിൽ *computer science* പോലുള്ള രണ്ട് വാക്കുകൾ ഉള്ള കുറവ് കീവർഡുകളും നമുക്ക് കിട്ടുന്നു. ഇത് കാരണം RAKE ആൽഗോറിതം വാക്കുകളിൽ നിന്ന് നല്ല കീവർഡ് തിരഞ്ഞെടുക്കുന്നതിൽ നല്ലതായ് പ്രവർത്തിക്കുന്നു. ഈ ഉദാഹരണം ഡാറ്റ പ്രീ-പ്രോസസിംഗിന്റെയും ക്ലീനിങ്ങിന്റെയും പ്രാധാന്യം കാണിക്കുന്നു, കാരണം അവസാനം സുതാര്യമായ ചിത്രം നമുക്ക് മികച്ച തീരുമാനം എടുക്കാൻ സഹായിക്കുന്നു.\n",
    "\n",
    "ഈ പ്രായോഗികത്തിൽ, കീവർഡുകളുടെയും വേഡ് ക്ലൗഡിന്റെയും രൂപത്തിൽ വിക്കിപീഡിയ കുറിപ്പിൽ നിന്ന് അർത്ഥം ധരിപ്പിക്കുന്ന ഒരു ലളിതമായ പ്രക്രിയ നമ്മൾ നടത്തി. ഈ ഉദാഹരണം വളരെ ലളിതമാണ്, എങ്കിലും ഡാറ്റാ സയન્ટിസ്റ്റ് ഡാറ്റ കൈകാര്യം ചെയ്യുമ്പോൾ എടുക്കുന്ന എല്ലാ സാധാരണ ഘട്ടങ്ങളും നല്ലതായാണ് കാണിക്കുന്നത്, ഡാറ്റ സമാഹരണത്തിൽ നിന്നും ദൃശ്യീകരണത്തിലേക്ക് വരെ ആരംഭിച്ച്.\n",
    "\n",
    "നമ്മുടെ കോഴ്സിൽ നാം ആ ഘട്ടങ്ങളെല്ലാം വിശദമായി ചര്‍ച്ച ചെയ്യും. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "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": "c28e7b6bf4e5b397b8288a85bf0a94ea8d3585ce2b01919feb195678ec71581b"
  },
  "kernelspec": {
   "display_name": "Python 3.8.11 64-bit ('base': conda)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}