{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NXTSugt6ieXh"
   },
   "source": [
    "## CBoW ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವುದು\n",
    "\n",
    "ಈ ನೋಟ್ಬುಕ್ [AI for Beginners Curriculum](http://aka.ms/ai-beginners) ಭಾಗವಾಗಿದೆ\n",
    "\n",
    "ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ನಮ್ಮದೇ Word2Vec ಎम्बೆಡ್ಡಿಂಗ್ ಸ್ಪೇಸ್ ಪಡೆಯಲು CBoW ಭಾಷಾ ಮಾದರಿಯನ್ನು ತರಬೇತುಗೊಳಿಸುವುದನ್ನು ನೋಡೋಣ. ನಾವು AG News ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪಠ್ಯದ ಮೂಲವಾಗಿ ಬಳಸುತ್ತೇವೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "import torch\n",
    "import torchtext\n",
    "import os\n",
    "import collections\n",
    "import builtins\n",
    "import random\n",
    "import numpy as np"
   ],
   "metadata": {
    "id": "q-UiiJUKaxHj"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ],
   "metadata": {
    "id": "TFbR8CZaTZ1q"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "ಮೊದಲು ನಮ್ಮ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಿ ಟೋಕನೈಜರ್ ಮತ್ತು ಶಬ್ದಕೋಶವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸೋಣ. ಗಣನೆಗಳನ್ನು ಸ್ವಲ್ಪ ಮಿತಿಗೊಳಿಸಲು ನಾವು `vocab_size` ಅನ್ನು 5000ಕ್ಕೆ ಹೊಂದಿಸುವೆವು.\n"
   ],
   "metadata": {
    "id": "HIwC7lI5T-ov"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def load_dataset(ngrams = 1, min_freq = 1, vocab_size = 5000 , lines_cnt = 500):\n",
    "    tokenizer = torchtext.data.utils.get_tokenizer('basic_english')\n",
    "    print(\"Loading dataset...\")\n",
    "    test_dataset, train_dataset  = torchtext.datasets.AG_NEWS(root='./data')\n",
    "    train_dataset = list(train_dataset)\n",
    "    test_dataset = list(test_dataset)\n",
    "    classes = ['World', 'Sports', 'Business', 'Sci/Tech']\n",
    "    print('Building vocab...')\n",
    "    counter = collections.Counter()\n",
    "    for i, (_, line) in enumerate(train_dataset):\n",
    "        counter.update(torchtext.data.utils.ngrams_iterator(tokenizer(line),ngrams=ngrams))\n",
    "        if i == lines_cnt:\n",
    "            break\n",
    "    vocab = torchtext.vocab.Vocab(collections.Counter(dict(counter.most_common(vocab_size))), min_freq=min_freq)\n",
    "    return train_dataset, test_dataset, classes, vocab, tokenizer"
   ],
   "metadata": {
    "id": "wdZuygtgiuLG"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "train_dataset, test_dataset, _, vocab, tokenizer = load_dataset()"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4d1nU1gsivGu",
    "outputId": "949fe272-ae0e-49f5-c373-6703458b3a74"
   },
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Loading dataset...\n",
      "Building vocab...\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "def encode(x, vocabulary, tokenizer = tokenizer):\n",
    "    return [vocabulary[s] for s in tokenizer(x)]"
   ],
   "metadata": {
    "id": "1XDYNhG8ToFV"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LIlQk6_PaHVY"
   },
   "source": [
    "## CBoW ಮಾದರಿ\n",
    "\n",
    "CBoW ಒಂದು ಪದವನ್ನು ಅದರ $2N$ ಹತ್ತಿರದ ಪದಗಳ ಆಧಾರದ ಮೇಲೆ ಊಹಿಸಲು ಕಲಿಯುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, $N=1$ ಆಗಿದ್ದಾಗ, *I like to train networks* ಎಂಬ ವಾಕ್ಯದಿಂದ ನಾವು ಕೆಳಗಿನ ಜೋಡಿಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ: (like,I), (I, like), (to, like), (like,to), (train,to), (to, train), (networks, train), (train,networks). ಇಲ್ಲಿ, ಮೊದಲ ಪದವು ಇನ್‌ಪುಟ್ ಆಗಿ ಬಳಸುವ ಹತ್ತಿರದ ಪದವಾಗಿದ್ದು, ಎರಡನೇ ಪದವು ನಾವು ಊಹಿಸುವ ಪದವಾಗಿದೆ.\n",
    "\n",
    "ಮುಂದಿನ ಪದವನ್ನು ಊಹಿಸಲು ನೆಟ್‌ವರ್ಕ್ ನಿರ್ಮಿಸಲು, ಹತ್ತಿರದ ಪದವನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ನೀಡಬೇಕು ಮತ್ತು ಪದದ ಸಂಖ್ಯೆಯನ್ನು ಔಟ್‌ಪುಟ್ ಆಗಿ ಪಡೆಯಬೇಕು. CBoW ನೆಟ್‌ವರ್ಕ್‌ನ ವಾಸ್ತುಶಿಲ್ಪ ಹೀಗಿದೆ:\n",
    "\n",
    "* ಇನ್‌ಪುಟ್ ಪದವನ್ನು embedding ಲೇಯರ್ ಮೂಲಕ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಈ embedding ಲೇಯರ್ ನಮ್ಮ Word2Vec embedding ಆಗಿದ್ದು, ಅದನ್ನು `embedder` ಎಂಬ ವ್ಯತ್ಯಾಸವಾಗಿ ಪ್ರತ್ಯೇಕವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುವೆವು. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ embedding ಗಾತ್ರ = 30 ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೂ ನೀವು ಹೆಚ್ಚಿನ ಆಯಾಮಗಳೊಂದಿಗೆ ಪ್ರಯೋಗ ಮಾಡಬಹುದು (ನಿಜವಾದ word2vec ನಲ್ಲಿ 300 ಇದೆ)\n",
    "* embedding ವೆಕ್ಟರ್ ನಂತರ ಔಟ್‌ಪುಟ್ ಪದವನ್ನು ಊಹಿಸುವ ಲೀನಿಯರ್ ಲೇಯರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಇದರಲ್ಲಿ `vocab_size` ನ್ಯೂರಾನ್ಗಳು ಇರುತ್ತವೆ.\n",
    "\n",
    "ಔಟ್‌ಪುಟ್‌ಗೆ, ನಾವು `CrossEntropyLoss` ಅನ್ನು ನಷ್ಟ ಕಾರ್ಯವಾಗಿ ಬಳಸಿದರೆ, ನಾವು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಾಗಿ ಪದದ ಸಂಖ್ಯೆಗಳನ್ನಷ್ಟೇ ಒದಗಿಸಬೇಕು, one-hot ಎನ್‌ಕೋಡಿಂಗ್ ಇಲ್ಲದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "vocab_size = len(vocab)\n",
    "\n",
    "embedder = torch.nn.Embedding(num_embeddings = vocab_size, embedding_dim = 30)\n",
    "model = torch.nn.Sequential(\n",
    "    embedder,\n",
    "    torch.nn.Linear(in_features = 30, out_features = vocab_size),\n",
    ")\n",
    "\n",
    "print(model)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "akKTcKQKkfl2",
    "outputId": "da687e3e-a8ec-4c1a-e456-ab8cd6ac7dad"
   },
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Sequential(\n",
      "  (0): Embedding(5002, 30)\n",
      "  (1): Linear(in_features=30, out_features=5002, bias=True)\n",
      ")\n"
     ]
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Nud6jgGPaHVa"
   },
   "source": [
    "## ತರಬೇತಿ ಡೇಟಾ ಸಿದ್ಧತೆ\n",
    "\n",
    "ಈಗ ನಾವು ಪಠ್ಯದಿಂದ CBoW ಪದ ಜೋಡಿಗಳನ್ನು ಲೆಕ್ಕಹಾಕುವ ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಪ್ರೋಗ್ರಾಮ್ ಮಾಡೋಣ. ಈ ಕಾರ್ಯವು ವಿಂಡೋ ಗಾತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತದೆ ಮತ್ತು ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಪದಗಳ ಜೋಡಿಗಳ ಸೆಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ಕಾರ್ಯವನ್ನು ಪದಗಳ ಮೇಲೆ ಮಾತ್ರವಲ್ಲದೆ ವೆಕ್ಟರ್‌ಗಳು/ಟೆನ್ಸರ್‌ಗಳ ಮೇಲೆ ಕೂಡ ಬಳಸಬಹುದು - ಇದು ಪಠ್ಯವನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ ನಂತರ `to_cbow` ಕಾರ್ಯಕ್ಕೆ ಪಾಸ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "x-dsXygOieXn",
    "outputId": "c2218280-e540-40ba-9546-efe48d0d714f"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[['like', 'I'], ['to', 'I'], ['I', 'like'], ['to', 'like'], ['train', 'like'], ['I', 'to'], ['like', 'to'], ['train', 'to'], ['networks', 'to'], ['like', 'train'], ['to', 'train'], ['networks', 'train'], ['to', 'networks'], ['train', 'networks']]\n",
      "[[232, 172], [5, 172], [172, 232], [5, 232], [0, 232], [172, 5], [232, 5], [0, 5], [1202, 5], [232, 0], [5, 0], [1202, 0], [5, 1202], [0, 1202]]\n"
     ]
    }
   ],
   "source": [
    "def to_cbow(sent,window_size=2):\n",
    "    res = []\n",
    "    for i,x in enumerate(sent):\n",
    "        for j in range(max(0,i-window_size),min(i+window_size+1,len(sent))):\n",
    "            if i!=j:\n",
    "                res.append([sent[j],x])\n",
    "    return res\n",
    "\n",
    "print(to_cbow(['I','like','to','train','networks']))\n",
    "print(to_cbow(encode('I like to train networks', vocab)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XVaaDLjaaHVb"
   },
   "source": [
    "ತರಬೇತಿ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸೋಣ. ನಾವು ಎಲ್ಲಾ ಸುದ್ದಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ, ಪದ ಜೋಡಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು `to_cbow` ಅನ್ನು ಕರೆಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಆ ಜೋಡಿಗಳನ್ನು `X` ಮತ್ತು `Y` ಗೆ ಸೇರಿಸುತ್ತೇವೆ. ಸಮಯದ ಕಾರಣಕ್ಕಾಗಿ, ನಾವು ಮೊದಲ 10,000 ಸುದ್ದಿಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುವೆವು - ನೀವು ಹೆಚ್ಚು ಸಮಯ ಕಾಯಲು ಸಾಧ್ಯವಿದ್ದರೆ ಮತ್ತು ಉತ್ತಮ ಎಂಬೆಡ್ಡಿಂಗ್‌ಗಳನ್ನು ಪಡೆಯಲು ಬಯಸಿದರೆ, ಈ ಮಿತಿ ಸುಲಭವಾಗಿ ತೆಗೆದುಹಾಕಬಹುದು :)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "54b-Gd9TieXo"
   },
   "outputs": [],
   "source": [
    "X = []\n",
    "Y = []\n",
    "for i, x in zip(range(10000), train_dataset):\n",
    "    for w1, w2 in to_cbow(encode(x[1], vocab), window_size = 5):\n",
    "        X.append(w1)\n",
    "        Y.append(w2)\n",
    "\n",
    "X = torch.tensor(X)\n",
    "Y = torch.tensor(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "ನಾವು ಆ ಡೇಟಾವನ್ನು ಒಂದೇ ಡೇಟಾಸೆಟ್‌ಗೆ ಪರಿವರ್ತಿಸಿ, ಡೇಟಾಲೋಡರ್ ಅನ್ನು ರಚಿಸುವೆವು:\n"
   ],
   "metadata": {
    "id": "cwWy0PzXWhN5"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class SimpleIterableDataset(torch.utils.data.IterableDataset):\n",
    "    def __init__(self, X, Y):\n",
    "        super(SimpleIterableDataset).__init__()\n",
    "        self.data = []\n",
    "        for i in range(len(X)):\n",
    "            self.data.append( (Y[i], X[i]) )\n",
    "        random.shuffle(self.data)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self.data)"
   ],
   "metadata": {
    "id": "mfoAcGPFZU8p"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e4NQ_-5waHVc"
   },
   "source": [
    "ನಾವು ಆ ಡೇಟಾವನ್ನು ಒಂದೇ ಡೇಟಾಸೆಟ್‌ಗೆ ಪರಿವರ್ತಿಸಿ, ಡೇಟಾಲೋಡರ್ ಅನ್ನು ರಚಿಸುವೆವು:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AbLUcojlieXo"
   },
   "outputs": [],
   "source": [
    "ds = SimpleIterableDataset(X, Y)\n",
    "dl = torch.utils.data.DataLoader(ds, batch_size = 256)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pKQr7sXeaHVc"
   },
   "source": [
    "ಈಗ ನಿಜವಾದ ತರಬೇತಿಯನ್ನು ಮಾಡೋಣ. ನಾವು `SGD` ಆಪ್ಟಿಮೈಜರ್ ಅನ್ನು ತುಂಬಾ ಹೆಚ್ಚಿನ ಲರ್ನಿಂಗ್ ರೇಟ್‌ನೊಂದಿಗೆ ಬಳಸುತ್ತೇವೆ. ನೀವು `Adam` ಮುಂತಾದ ಇತರ ಆಪ್ಟಿಮೈಜರ್‌ಗಳೊಂದಿಗೆ ಕೂಡ ಪ್ರಯೋಗ ಮಾಡಬಹುದು. ನಾವು ಪ್ರಾರಂಭದಲ್ಲಿ 10 ಎಪೋಕ್‌ಗಳಿಗಾಗಿ ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ - ಮತ್ತು ನೀವು ಇನ್ನಷ್ಟು ಕಡಿಮೆ ಲಾಸ್‌ಗಾಗಿ ಈ ಸೆಲ್ ಅನ್ನು ಮರುನಡೆಸಬಹುದು.\n"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "def train_epoch(net, dataloader, lr = 0.01, optimizer = None, loss_fn = torch.nn.CrossEntropyLoss(), epochs = None, report_freq = 1):\n",
    "    optimizer = optimizer or torch.optim.Adam(net.parameters(), lr = lr)\n",
    "    loss_fn = loss_fn.to(device)\n",
    "    net.train()\n",
    "\n",
    "    for i in range(epochs):\n",
    "        total_loss, j = 0, 0, \n",
    "        for labels, features in dataloader:\n",
    "            optimizer.zero_grad()\n",
    "            features, labels = features.to(device), labels.to(device)\n",
    "            out = net(features)\n",
    "            loss = loss_fn(out, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            total_loss += loss\n",
    "            j += 1\n",
    "        if i % report_freq == 0:\n",
    "            print(f\"Epoch: {i+1}: loss={total_loss.item()/j}\")\n",
    "\n",
    "    return total_loss.item()/j"
   ],
   "metadata": {
    "id": "HeeCYKr_KF1w"
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "train_epoch(net = model, dataloader = dl, optimizer = torch.optim.SGD(model.parameters(), lr = 0.1), loss_fn = torch.nn.CrossEntropyLoss(), epochs = 10)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KVgwGtDHgDlT",
    "outputId": "2447833f-f0e3-4566-c33d-addbfe2f451d"
   },
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Epoch: 1: loss=5.664632366860172\n",
      "Epoch: 2: loss=5.632101973960962\n",
      "Epoch: 3: loss=5.610399051405015\n",
      "Epoch: 4: loss=5.594621561080262\n",
      "Epoch: 5: loss=5.582538017415446\n",
      "Epoch: 6: loss=5.572900234519603\n",
      "Epoch: 7: loss=5.564951676341915\n",
      "Epoch: 8: loss=5.558288112064614\n",
      "Epoch: 9: loss=5.552576955031129\n",
      "Epoch: 10: loss=5.547634165194347\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "5.547634165194347"
      ]
     },
     "metadata": {},
     "execution_count": 16
    }
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W8u2qXZmaHVd"
   },
   "source": [
    "## Word2Vec ಪ್ರಯತ್ನಿಸುವುದು\n",
    "\n",
    "Word2Vec ಬಳಸಲು, ನಮ್ಮ ಶಬ್ದಕೋಶದಲ್ಲಿರುವ ಎಲ್ಲಾ ಪದಗಳಿಗೆ ಹೊಂದಿಕೊಂಡಿರುವ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯೋಣ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r8TatcXjkU_t"
   },
   "outputs": [],
   "source": [
    "vectors = torch.stack([embedder(torch.tensor(vocab[s])) for s in vocab.itos], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3OcX21UOaHVd"
   },
   "source": [
    "ನೋಡೋಣ, ಉದಾಹರಣೆಗೆ, **ಪ್ಯಾರಿಸ್** ಎಂಬ ಪದವನ್ನು ಹೇಗೆ ವೆಕ್ಟರ್ ಆಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡಲಾಗಿದೆ:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bz6tAeLzieXp",
    "outputId": "5b20850e-4342-45e9-f840-cfac2b4d61d8"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "tensor([-0.0915,  2.1224, -0.0281, -0.6819,  1.1219,  0.6458, -1.3704, -1.3314,\n",
      "        -1.1437,  0.4496,  0.2301, -0.3515, -0.8485,  1.0481,  0.4386, -0.8949,\n",
      "         0.5644,  1.0939, -2.5096,  3.2949, -0.2601, -0.8640,  0.1421, -0.0804,\n",
      "        -0.5083, -1.0560,  0.9753, -0.5949, -1.6046,  0.5774],\n",
      "       grad_fn=<EmbeddingBackward>)\n"
     ]
    }
   ],
   "source": [
    "paris_vec = embedder(torch.tensor(vocab['paris']))\n",
    "print(paris_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pHTJlaeYaHVd"
   },
   "source": [
    "ಪರ್ಯಾಯ ಪದಗಳನ್ನು ಹುಡುಕಲು Word2Vec ಬಳಸುವುದು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ. ಕೆಳಗಿನ ಫಂಕ್ಷನ್ ನೀಡಲಾದ ಇನ್‌ಪುಟ್‌ಗೆ `n` ಅತ್ಯಂತ ಸಮೀಪದ ಪದಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅವುಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು $|w_i - v|$ ನಾರ್ಮ್ ಅನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತೇವೆ, ಇಲ್ಲಿ $v$ ನಮ್ಮ ಇನ್‌ಪುಟ್ ಪದಕ್ಕೆ ಹೊಂದಿರುವ ವೆಕ್ಟರ್ ಆಗಿದ್ದು, $w_i$ ಶಬ್ದಕೋಶದಲ್ಲಿನ i-ನೇ ಪದದ ಎನ್‌ಕೋಡಿಂಗ್ ಆಗಿದೆ. ನಂತರ ನಾವು ಅರೇ ಅನ್ನು ಸರಿದೂಗಿಸಿ `argsort` ಬಳಸಿ ಸಂಬಂಧಿತ ಸೂಚ್ಯಂಕಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ, ಮತ್ತು ಮೊದಲ `n` ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಅವು ಶಬ್ದಕೋಶದಲ್ಲಿನ ಸಮೀಪದ ಪದಗಳ ಸ್ಥಾನಗಳನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡುತ್ತವೆ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NlZyi-_olFar",
    "outputId": "b5dbb163-88c4-4d5a-eaf2-6751f700e98c"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "['microsoft', 'quoted', 'lp', 'rate', 'top']"
      ]
     },
     "metadata": {},
     "execution_count": 56
    }
   ],
   "source": [
    "def close_words(x, n = 5):\n",
    "  vec = embedder(torch.tensor(vocab[x]))\n",
    "  top5 = np.linalg.norm(vectors.detach().numpy() - vec.detach().numpy(), axis = 1).argsort()[:n]\n",
    "  return [ vocab.itos[x] for x in top5 ]\n",
    "\n",
    "close_words('microsoft')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-dQq7xeAln0U",
    "outputId": "66f768c3-c248-4bfd-ce4f-c8ffc6d0dd0d"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "['basketball', 'lot', 'sinai', 'states', 'healthdaynews']"
      ]
     },
     "metadata": {},
     "execution_count": 51
    }
   ],
   "source": [
    "close_words('basketball')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fJXqK26b29sa",
    "outputId": "78f0baba-ffd0-485a-dd87-0a12bedfd7fa"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "['funds', 'travel', 'sydney', 'japan', 'business']"
      ]
     },
     "metadata": {},
     "execution_count": 77
    }
   ],
   "source": [
    "close_words('funds')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "My0VeTDd3Ji8"
   },
   "source": [
    "## ಸಾರಾಂಶ\n",
    "\n",
    "CBoW ಮುಂತಾದ ಚತುರ ತಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು Word2Vec ಮಾದರಿಯನ್ನು ತರಬೇತಿಮಾಡಬಹುದು. ಕೇಂದ್ರ ಪದವನ್ನು ನೀಡಿದಾಗ ಹತ್ತಿರದ ಪದವನ್ನು ಊಹಿಸಲು ತರಬೇತಿಮಾಡುವ skip-gram ಮಾದರಿಯನ್ನು ಕೂಡ ಪ್ರಯತ್ನಿಸಿ, ಅದು ಎಷ್ಟು ಚೆನ್ನಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೋಡಿ.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**ಅಸ್ವೀಕರಣ**:  \nಈ ದಸ್ತಾವೇಜು [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಅನುವಾದ ಸೇವೆಯನ್ನು ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯತ್ತ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "CBoW-PyTorch.ipynb",
   "provenance": []
  },
  "interpreter": {
   "hash": "16af2a8bbb083ea23e5e41c7f5787656b2ce26968575d8763f2c4b17f9cd711f"
  },
  "kernelspec": {
   "display_name": "Python 3.8.12 ('py38')",
   "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.8.12"
  },
  "orig_nbformat": 4,
  "gpuClass": "standard",
  "coopTranslator": {
   "original_hash": "36df28efe3fe40b6fb0a7fa48fe3ea82",
   "translation_date": "2025-11-26T01:55:55+00:00",
   "source_file": "lessons/5-NLP/15-LanguageModeling/CBoW-PyTorch.ipynb",
   "language_code": "kn"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}