Data-Science-For-Beginners/translations/kn/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 ಮೂಲ ಕೋಡ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ್ದು, ಅದನ್ನು ಸರಳ ಪಠ್ಯವಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಅಗತ್ಯ.\n",
    "\n",
    "ಇದನ್ನು ಮಾಡಲು ಹಲವು ವಿಧಾನಗಳಿವೆ. ನಾವು [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/) ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ, ಇದು HTML ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವ ಜನಪ್ರಿಯ Python ಲೈಬ್ರರಿಯಾಗಿದೆ. BeautifulSoup ನಮಗೆ ನಿರ್ದಿಷ್ಟ HTML ಅಂಶಗಳನ್ನು ಗುರಿಯಾಗಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ವಿಕಿಪೀಡಿಯಾದ ಪ್ರಮುಖ ಲೇಖನ ವಿಷಯದ ಮೇಲೆ ಒತ್ತು ನೀಡಬಹುದು ಮತ್ತು ಕೆಲವು ನ್ಯಾವಿಗೇಶನ್ ಮೆನುಗಳು, ಸೈಡ್‌ಬಾರ್ಗಳು, ಫೂಟರ್‌ಗಳು ಮತ್ತು ಇತರ ಅನಗತ್ಯ ವಿಷಯಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು (ಆದರೆ ಕೆಲವು ಬೋಯ್ಲರ್‌ಪ್ಲೇಟ್ ಪಠ್ಯ ಇನ್ನೂ ಉಳಿಯಬಹುದು).\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",
    "ನಾವು ಪೈಥಾನ್ ಲೈಬ್ರರಿ [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` ವಸ್ತುವಿನಿಂದ ಲಭ್ಯವಿದ್ದು, ಅದನ್ನು ಕೆಲವು ನಿಯಾಮಕಗಳನ್ನು ಬಳಸಿ ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿ, ನಾವು ಕೀವರ್ಡ್‌ನ ಕನಿಷ್ಠ ಉದ್ದವನ್ನು 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",
    "ಜನರು ಡೇಟಾವನ್ನು ದೃಶ್ಯ ರೂಪದಲ್ಲಿ ಅತ್ಯುತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು. ಆದ್ದರಿಂದ ಕೆಲವು ಆಳವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪಡೆಯಲು ಡೇಟಾವನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು ಸದಾ ಸೂಕ್ತವಾಗಿದೆ. ಕ್ಯುಮಾನದ ಸಾದಾ ಶಬ್ದಪದಗಳ ಹಿತಪೂರ್ಣ ವಿತರಣೆಯನ್ನು ಚಿತ್ರಿಸಲು Python ನಲ್ಲಿ `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
}