word2vec-trainer-pytorch 0.1.0__tar.gz

word2vec_trainer_pytorch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abhishek Biswas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

word2vec_trainer_pytorch-0.1.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: word2vec-trainer-pytorch
+Version: 0.1.0
+Summary: A PyTorch implementation of Word2Vec for learning and experimentation
+Author-email: Abhishek Biswas <rohan.abiswas@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Abhishek Biswas
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Repository, https://github.com/AbhishekBiswas12/word2vec_trainer
+Project-URL: Issues, https://github.com/AbhishekBiswas12/word2vec_trainer/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: tqdm>=4.64
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: pytest>=9.1.0
+Dynamic: license-file
+
+# Word2Vec Trainer
+
+A PyTorch implementation of **Word2Vec** built as a learning project to understand how word embeddings are trained.
+
+## About
+
+I wanted to understand Word2Vec beyond the API, so I implemented the training pipeline myself and packaged it as a Python library. I built this project while learning about **Word2Vec, Skip-gram, negative sampling, and word embeddings**.
+
+The goal was to implement the main components myself and understand how they work rather than treating Word2Vec as a black box.
+
+The project includes:
+
+- Text preprocessing
+- Vocabulary creation
+- Training pair generation
+- Skip-gram model
+- Negative sampling
+- Model training with PyTorch
+
+## Project Structure
+
+```text
+word2vec_trainer/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+│
+├── src/
+│   └── word2vec_trainer/
+│       ├── dataset_loader.py
+│       ├── word2vec_model.py
+│       ├── preprocessing.py
+│       └── trainer.py
+│
+├── tests/
+│   ├── test_dataset.py
+│   ├── test_preprocessing.py
+│   ├── test_model.py
+│   └── test_trainer.py
+│
+└── examples/
+    └── basic_training.py
+```
+
+## Training Pipeline
+
+```text
+Text without commas or special characters
+   ↓
+Preprocessing
+   ↓
+Vocabulary
+   ↓
+Training Pairs
+   ↓
+Negative Sampling
+   ↓
+Skip-gram Model
+   ↓
+Learned Word Embeddings
+```
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AbhishekBiswas12/word2vec_trainer.git
+cd word2vec_trainer
+```
+
+Install in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+## Usage
+
+A basic training example is available in:
+
+```text
+examples/basic_training.py
+```
+
+The public API is still evolving as the project develops.
+
+## Testing
+
+Run the test suite with:
+
+```bash
+pytest
+```
+
+## AI-Assisted Development
+
+This project was built primarily as a learning exercise.
+
+During development, I occasionally used **ChatGPT** and **Google Colab's coding assistant** when I got stuck with implementation details, debugging, or understanding concepts.
+
+I used these tools as learning and development assistance while working to understand the underlying implementation.
+
+## Status
+
+🚧 **Work in progress**
+
+Future improvements include:
+
+- Improve the public API
+- Expand test coverage
+- Add more examples
+- Add embedding evaluation and visualization
+- Benchmark different training configurations
+- Publish the package to PyPI
+
+## References
+
+- [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/abs/1301.3781)
+- [Distributed Representations of Words and Phrases and their Compositionality](https://arxiv.org/abs/1310.4546)
+- [The Illustrated Word2Vec](https://jalammar.github.io/illustrated-word2vec/)
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

word2vec_trainer_pytorch-0.1.0/README.md

@@ -0,0 +1,126 @@
+# Word2Vec Trainer
+
+A PyTorch implementation of **Word2Vec** built as a learning project to understand how word embeddings are trained.
+
+## About
+
+I wanted to understand Word2Vec beyond the API, so I implemented the training pipeline myself and packaged it as a Python library. I built this project while learning about **Word2Vec, Skip-gram, negative sampling, and word embeddings**.
+
+The goal was to implement the main components myself and understand how they work rather than treating Word2Vec as a black box.
+
+The project includes:
+
+- Text preprocessing
+- Vocabulary creation
+- Training pair generation
+- Skip-gram model
+- Negative sampling
+- Model training with PyTorch
+
+## Project Structure
+
+```text
+word2vec_trainer/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+│
+├── src/
+│   └── word2vec_trainer/
+│       ├── dataset_loader.py
+│       ├── word2vec_model.py
+│       ├── preprocessing.py
+│       └── trainer.py
+│
+├── tests/
+│   ├── test_dataset.py
+│   ├── test_preprocessing.py
+│   ├── test_model.py
+│   └── test_trainer.py
+│
+└── examples/
+    └── basic_training.py
+```
+
+## Training Pipeline
+
+```text
+Text without commas or special characters
+   ↓
+Preprocessing
+   ↓
+Vocabulary
+   ↓
+Training Pairs
+   ↓
+Negative Sampling
+   ↓
+Skip-gram Model
+   ↓
+Learned Word Embeddings
+```
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AbhishekBiswas12/word2vec_trainer.git
+cd word2vec_trainer
+```
+
+Install in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+## Usage
+
+A basic training example is available in:
+
+```text
+examples/basic_training.py
+```
+
+The public API is still evolving as the project develops.
+
+## Testing
+
+Run the test suite with:
+
+```bash
+pytest
+```
+
+## AI-Assisted Development
+
+This project was built primarily as a learning exercise.
+
+During development, I occasionally used **ChatGPT** and **Google Colab's coding assistant** when I got stuck with implementation details, debugging, or understanding concepts.
+
+I used these tools as learning and development assistance while working to understand the underlying implementation.
+
+## Status
+
+🚧 **Work in progress**
+
+Future improvements include:
+
+- Improve the public API
+- Expand test coverage
+- Add more examples
+- Add embedding evaluation and visualization
+- Benchmark different training configurations
+- Publish the package to PyPI
+
+## References
+
+- [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/abs/1301.3781)
+- [Distributed Representations of Words and Phrases and their Compositionality](https://arxiv.org/abs/1310.4546)
+- [The Illustrated Word2Vec](https://jalammar.github.io/illustrated-word2vec/)
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

word2vec_trainer_pytorch-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "word2vec-trainer-pytorch"
+version = "0.1.0"
+description = "A PyTorch implementation of Word2Vec for learning and experimentation"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+
+authors = [
+    { name = "Abhishek Biswas", email = "rohan.abiswas@gmail.com" }
+]
+
+dependencies = [
+    "torch>=2.0",
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "tqdm>=4.64",
+    "matplotlib>=3.8.0",
+    "pytest>=9.1.0"
+]
+
+[project.urls]
+Repository = "https://github.com/AbhishekBiswas12/word2vec_trainer"
+Issues = "https://github.com/AbhishekBiswas12/word2vec_trainer/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

word2vec_trainer_pytorch-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer/dataset_loader.py

@@ -0,0 +1,80 @@
+import torch
+from torch.utils.data import IterableDataset
+import numpy as np
+import math
+from tqdm.auto import tqdm
+
+class DatasetLoader(IterableDataset):
+    total_batches = 0
+    def __init__(self, file_path, batch_size, path_to_neg_dist="neg_distribution.npy", neg_num=5):
+        self.file_path = file_path
+        self.batch_size = batch_size
+        self.neg_num = neg_num
+        with open(file_path) as f:
+            self.length = sum(1 for _ in f) - 1
+        self.neg_dist = np.load(path_to_neg_dist)
+        self.total_batches=math.ceil((self.length * (1 + self.neg_num))/self.batch_size)
+
+    def __len__(self):
+        return self.length * (1+self.neg_num)
+
+    def gen_negatives(self, contexts, targets, batch):
+      negatives = np.random.choice(
+        len(self.neg_dist),
+        size=(len(contexts), self.neg_num),
+        p=self.neg_dist
+      )
+      for n, t, c in zip(negatives, targets, contexts):
+        for i in range(len(n)):
+          while n[i] == t:
+            n[i] = np.random.choice(
+              len(self.neg_dist),
+              p=self.neg_dist
+            )
+        batch.extend(
+            (c, neg, 0) for neg in n
+        )
+      return batch
+
+    def __iter__(self):
+        with open(self.file_path) as f:
+            next(f)  # skip header
+            np.random.seed(42)
+            batch = []
+            targets = []
+            contexts = []
+
+            pbar = tqdm(
+              total=math.ceil(
+                  (self.length * (1 + self.neg_num))/self.batch_size
+              ),
+              desc="Loading batches",
+              unit="batches"
+            )
+
+            for line in f:
+              context, target, label = line.strip().split(',')
+              context = int(context)
+              target = int(target)
+              label = int(label)
+              contexts.append(context)
+              targets.append(target)
+              batch.append((context, target, label))
+              if len(contexts)==10000:
+                batch = self.gen_negatives(contexts, targets, batch)
+                contexts = []
+                targets = []
+                while len(batch) >= self.batch_size:
+                  pbar.update(1)
+                  yield torch.tensor(
+                      batch[:self.batch_size]
+                  )
+
+                  batch = batch[self.batch_size:]
+            if contexts:
+              batch = self.gen_negatives(contexts, targets, batch)
+
+            if batch:
+              pbar.update(1)
+              yield torch.tensor(batch)
+            pbar.close()

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer/preprocessing.py

@@ -0,0 +1,161 @@
+import pandas as pd
+from tqdm.auto import tqdm
+import math
+import random
+import numpy as np
+import csv
+
+class Preprocessing:
+  vocabulary_size = None
+  def __init__(self, 
+               cleaned_data_file_path = 'cleaned_data.txt',
+               subsampled_file_path = 'subsampled_data.txt',
+               vocabulary_file = 'vocabulary.csv',
+               pos_example = 'pos_examples.csv',
+               train_path = 'train_w2v.csv',
+               train_ratio = 0.95,
+               valid_path = 'valid_w2v.csv',
+               valid_ratio = 0.025,
+               test_path = 'test_w2v.csv',
+               test_ratio = 0.025,
+               window = 5):
+    self.cleaned_data_file_path = cleaned_data_file_path
+    self.subsampled_file_path = subsampled_file_path
+    self.vocabulary_file = vocabulary_file
+    self.pos_examples = pos_example
+    self.window = window
+    self.train_path = train_path
+    self.train_ratio = train_ratio
+    self.valid_path = valid_path
+    self.valid_ratio = valid_ratio
+    self.test_path = test_path
+    self.test_ratio = test_ratio
+    with open(self.pos_examples, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        # Write header
+        writer.writerow(('int', 'target', 'pred'))
+
+  def run(self):
+    count_word = self.vocabulary_subsampling()
+    self.negative_distribution_calc()
+    self.positive_example_gen(count_word)
+    print('Generated Positive examples.')
+    print('Splitting data into train, test and valid sets.')
+    self.train_test_val_split()
+
+  def vocabulary_subsampling(self):
+    cleaned_text = open(self.cleaned_data_file_path, 'r').read()
+    print('Creating Vocabulary...')
+    vocabulary = pd.DataFrame(pd.DataFrame(cleaned_text.split(" ")).value_counts())[pd.DataFrame(pd.DataFrame(cleaned_text.split(" ")).value_counts())['count'] >= 2]
+    vocabulary.reset_index(inplace=True)
+    print('Columns of vocabulary:', vocabulary.columns)
+    vocabulary.loc[len(vocabulary)] = [r'<UNK>', 0]
+    vocabulary.rename(columns={0: 'Word'}, inplace=True)
+    print("Created Vocabulary.")
+    vocabulary.to_csv(self.vocabulary_file)
+    self.vocabulary_size = len(vocabulary.index)
+    print('Saved vocabulary.')
+
+    # subsampling
+    word_int = {v:k for k, v in vocabulary['Word'].to_dict().items()}
+    word_freqs = vocabulary["count"].to_dict()
+    cleaned_text_int = []
+    c=0
+    unk = 0
+    for word in tqdm(cleaned_text.split(" "), desc='Converting words to integers'):
+      if word in word_int.keys():
+        cleaned_text_int.append(word_int[word])
+      else:
+        cleaned_text_int.append(word_int[r'<UNK>'])
+        unk+=1
+      c+=1
+
+    t = 1e-5
+    keep_probs = {}
+    for word, freq in word_freqs.items():
+      if word == len(vocabulary)-1:
+        keep_prob = (math.sqrt((unk/c) / t) + 1) * (t / (unk/c))
+      else:
+        keep_prob = (math.sqrt((freq/c) / t) + 1) * (t / (freq/c))
+      keep_prob = min(1.0, keep_prob)
+      keep_probs[word] = keep_prob
+
+    count_word = 0
+    with open(self.subsampled_file_path, 'w') as f:
+      for i in tqdm(cleaned_text_int, desc="Subsampling common words"):
+        if random.random() >= keep_probs[i]:
+          continue
+        f.write(str(i) + ' ')
+        count_word+=1
+    print('Subsampling finished')
+    return count_word
+
+  def negative_distribution_calc(self):
+    text = open(self.subsampled_file_path, 'r').read().split(" ")[:-1]
+    text = [int(num) for num in text]
+    counts = np.bincount(text)
+    scaled_counts = counts**0.75
+    neg_dist = (scaled_counts/np.sum(scaled_counts))
+    np.save('neg_distribution_test.npy', neg_dist)
+
+  def positive_example_gen(self, counts):
+    sampled_text = open(self.subsampled_file_path, 'r').read().split(" ")[:-1]
+    sampled_text = [int(x) for x in sampled_text]
+    window = self.window
+    pairs = {
+        'int': [],
+        'target': [],
+        'pred': []
+    }
+    for i in tqdm(range(self.window, counts-window-1), desc='Computing positive pairs'):
+      dic = {
+          'int': [sampled_text[i]]*(window*2),
+          'target':sampled_text[i-window:i] + sampled_text[i+1:i+window+1],
+          'pred': [1]*(window*2)
+      }
+      pairs['int'].extend(dic['int'])
+      pairs['target'].extend(dic['target'])
+      pairs['pred'].extend(dic['pred'])
+
+      with open(self.pos_examples, "a", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerows(zip(*pairs.values()))
+        pairs = {
+          'int': [],
+          'target': [],
+          'pred': []
+        }
+  
+  def train_test_val_split(self):
+    train_count = 0
+    test_count = 0
+    valid_count = 0
+
+    with open(self.pos_examples, "r", newline="", encoding="utf-8") as infile, \
+        open(self.train_path, "w", newline="", encoding="utf-8") as train_out, \
+        open(self.valid_path, "w", newline="", encoding="utf-8") as valid_out, \
+        open(self.test_path, "w", newline="", encoding="utf-8") as test_out:
+      reader = csv.reader(infile)
+      train_writer = csv.writer(train_out)
+      valid_writer = csv.writer(valid_out)
+      test_writer = csv.writer(test_out)
+
+      header = next(reader)
+
+      train_writer.writerow(header)
+      valid_writer.writerow(header)
+      test_writer.writerow(header)
+      for row in tqdm(reader, desc='Splitting data into train, test and valid sets'):
+        r = random.random()
+        if r < self.train_ratio:
+          train_writer.writerow(row)
+          train_count+=1
+        elif r < self.train_ratio + self.valid_ratio:
+          valid_writer.writerow(row)
+          valid_count+=1
+        else:
+          test_writer.writerow(row)
+          test_count+=1
+      print('Final Train count: ',train_count)
+      print('Final Valid count: ', valid_count)
+      print('Final Test count: ', test_count)

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer/trainer.py

@@ -0,0 +1,162 @@
+import torch
+import torch.nn.functional as F
+import torch.optim as op
+import numpy as np
+import math
+from tqdm.auto import tqdm
+from word2vec_trainer.dataset_loader import DatasetLoader
+from word2vec_trainer.word2vec_model import Word2Vec
+
+class Trainer:
+    def __init__(
+        self,
+        vocab_size = 508205,
+        embedding_dim = 300,
+        batch_size_train = 1500000,
+        batch_size_val = 50000,
+        new_model = True,
+        path_to_train = "train.csv",
+        path_to_val = "val_csv",
+        path_to_saved_model = "",
+        path_to_neg_dist = "neg_distribution.npy",
+        epochs = 50,
+        lr = 0.01
+    ):
+        # assigning variable values
+        self.vocab_size = vocab_size
+        self.embedding_dim = embedding_dim
+        self.batch_size_train = batch_size_train
+        self.batch_size_val = batch_size_val
+        self.new_model = new_model
+        self.path_to_train = path_to_train
+        self.path_to_val = path_to_val
+        self.path_to_saved_model = path_to_saved_model if path_to_saved_model != "" else 'word2vec_model.bin' 
+        self.path_to_neg_dist = path_to_neg_dist
+        self.epochs = epochs
+
+        # creating dataset and model objects
+        self.train = DatasetLoader(
+                    path_to_train,
+                    batch_size_train,
+                    path_to_neg_dist=self.path_to_neg_dist,
+                    neg_num=2)
+        self.val = DatasetLoader(
+                    path_to_val,
+                    batch_size_val,
+                    path_to_neg_dist=self.path_to_neg_dist,
+                    neg_num=2)
+        self.model = self.model_creation()
+        self.model.requires_grad_(True)
+
+        # Learning rate, optimizer, loss selection -> TODO: assign from user choice
+        self.lr = lr
+        self.optimizer = op.Adagrad(self.model.parameters(), lr=self.lr)
+        self.loss = torch.nn.BCEWithLogitsLoss()
+
+    def run(self):
+        self.train_model()
+        
+        
+    def model_creation(self):
+        if self.new_model:
+            print("Creating train_losses.txt")
+            open('train_losses.txt', 'w').close()
+            print("Creating val_losses.txt")
+            open('val_losses.txt', 'w').close()
+            return Word2Vec(self.vocab_size, self.embedding_dim)            
+        else:
+            return torch.load(self.path_to_saved_model, weights_only=False) 
+
+    def validate_model(self, device='cpu'):
+        val_loss = 0.0
+        val_size = 0
+        
+        train_pos_probs = 0.0
+        train_neg_probs = 0.0
+        train_pos_size = 0
+        train_neg_size = 0
+        val_pos_probs = 0.0
+        val_neg_probs = 0.0
+        val_pos_size = 0
+        val_neg_size = 0
+        
+        train_loss = 0.0
+        train_size = 0
+        self.model.eval()
+        
+        with torch.no_grad():
+            for x in tqdm(self.train, desc=f"Computing Train Loss", total=self.train.total_batches):
+                context = x[:, 0].to(device)
+                target = x[:, 1].to(device)
+                labels = x[:, 2].to(device)
+                scores = self.model(context, target)
+                probs = torch.sigmoid(scores)
+                
+                train_pos_probs += probs[labels == 1].sum().item()
+                train_neg_probs += probs[labels == 0].sum().item()
+                
+                train_pos_size += probs[labels==1].size()[0]
+                train_neg_size += probs[labels==0].size()[0]
+                
+                l = self.loss(scores, labels.float())
+                train_loss += l.item() * context.shape[0]
+                train_size += context.shape[0]
+            
+            for y in tqdm(self.val, desc=f"Computing Validation Loss", total=self.val.total_batches):
+                context = y[:, 0].to(device)
+                target = y[:, 1].to(device)
+                labels = y[:, 2].to(device)
+                
+                scores = self.model(context, target)
+                probs = torch.sigmoid(scores)
+                
+                val_pos_probs += probs[labels == 1].sum().item()
+                val_neg_probs += probs[labels == 0].sum().item()
+                
+                val_pos_size += probs[labels==1].size()[0]
+                val_neg_size += probs[labels==0].size()[0]
+                
+                l = self.loss(scores, labels.float())
+                val_loss += l.item() * context.shape[0]
+                val_size += context.shape[0]
+            
+        train_loss /= train_size
+        val_loss /= val_size
+        
+        train_pos_probs /= train_pos_size
+        train_neg_probs /= train_neg_size
+        
+        val_pos_probs /= val_pos_size
+        val_neg_probs /= val_neg_size
+        
+        self.model.train()
+        return train_loss, train_pos_probs, train_neg_probs, val_loss, val_pos_probs, val_neg_probs
+
+    def train_model(self):
+        epoch = len(open('train_losses.txt', 'r').readlines())
+        print("starting training...")
+        for epoch in range(epoch, self.epochs):
+            self.optimizer.zero_grad()
+            for x in tqdm(self.train, desc=f"Epoch {epoch+1}", total=self.train.total_batches):
+                context = x[:, 0]
+                target = x[:, 1]
+                labels = x[:, 2]
+                
+                batch_size = target.shape[0]
+                
+                # Forward
+                scores = self.model(context, target)
+                
+                l = self.loss(scores, labels.float())
+                
+                # Backprop
+                l.backward()
+            self.optimizer.step()
+            train_loss, train_pos_probs, train_neg_probs, val_loss, val_pos_probs, val_neg_probs = self.validate_model()
+            with open('train_losses.txt', 'a') as losses, open('val_losses.txt', 'a') as val_losses:
+                losses.write(f"{train_loss}\t{train_pos_probs}\t{train_neg_probs}\n")
+                val_losses.write(f"{val_loss}\t{val_pos_probs}\t{val_neg_probs}\n")
+                print(f"Epoch {epoch+1}, Loss: {train_loss}, Positive probabs: {train_pos_probs}, Negative probabs: {train_neg_probs}\n Val_loss: {val_loss}, Positive probabs {val_pos_probs}, Negative probabs: {val_neg_probs}")  
+                if self.path_to_saved_model != '':
+                    torch.save(self.model, self.path_to_saved_model)
+                    print(f"Model saved after {epoch+1} epochs")

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer/word2vec_model.py

@@ -0,0 +1,13 @@
+import torch
+
+class Word2Vec(torch.nn.Module):
+    def __init__(self, vocab_size, embedding_dim):
+        super().__init__()
+        self.input_embedding_layer = torch.nn.Embedding(vocab_size, embedding_dim)
+        self.output_embedding_layer = torch.nn.Embedding(vocab_size, embedding_dim)
+        
+    def forward(self, x, y):
+        e1 = self.input_embedding_layer(x)
+        e2 = self.output_embedding_layer(y)
+        
+        return (e1 * e2).sum(dim=1)

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer_pytorch.egg-info/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: word2vec-trainer-pytorch
+Version: 0.1.0
+Summary: A PyTorch implementation of Word2Vec for learning and experimentation
+Author-email: Abhishek Biswas <rohan.abiswas@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Abhishek Biswas
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Repository, https://github.com/AbhishekBiswas12/word2vec_trainer
+Project-URL: Issues, https://github.com/AbhishekBiswas12/word2vec_trainer/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: tqdm>=4.64
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: pytest>=9.1.0
+Dynamic: license-file
+
+# Word2Vec Trainer
+
+A PyTorch implementation of **Word2Vec** built as a learning project to understand how word embeddings are trained.
+
+## About
+
+I wanted to understand Word2Vec beyond the API, so I implemented the training pipeline myself and packaged it as a Python library. I built this project while learning about **Word2Vec, Skip-gram, negative sampling, and word embeddings**.
+
+The goal was to implement the main components myself and understand how they work rather than treating Word2Vec as a black box.
+
+The project includes:
+
+- Text preprocessing
+- Vocabulary creation
+- Training pair generation
+- Skip-gram model
+- Negative sampling
+- Model training with PyTorch
+
+## Project Structure
+
+```text
+word2vec_trainer/
+│
+├── pyproject.toml
+├── README.md
+├── LICENSE
+│
+├── src/
+│   └── word2vec_trainer/
+│       ├── dataset_loader.py
+│       ├── word2vec_model.py
+│       ├── preprocessing.py
+│       └── trainer.py
+│
+├── tests/
+│   ├── test_dataset.py
+│   ├── test_preprocessing.py
+│   ├── test_model.py
+│   └── test_trainer.py
+│
+└── examples/
+    └── basic_training.py
+```
+
+## Training Pipeline
+
+```text
+Text without commas or special characters
+   ↓
+Preprocessing
+   ↓
+Vocabulary
+   ↓
+Training Pairs
+   ↓
+Negative Sampling
+   ↓
+Skip-gram Model
+   ↓
+Learned Word Embeddings
+```
+
+## Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/AbhishekBiswas12/word2vec_trainer.git
+cd word2vec_trainer
+```
+
+Install in editable mode:
+
+```bash
+python -m pip install -e .
+```
+
+## Usage
+
+A basic training example is available in:
+
+```text
+examples/basic_training.py
+```
+
+The public API is still evolving as the project develops.
+
+## Testing
+
+Run the test suite with:
+
+```bash
+pytest
+```
+
+## AI-Assisted Development
+
+This project was built primarily as a learning exercise.
+
+During development, I occasionally used **ChatGPT** and **Google Colab's coding assistant** when I got stuck with implementation details, debugging, or understanding concepts.
+
+I used these tools as learning and development assistance while working to understand the underlying implementation.
+
+## Status
+
+🚧 **Work in progress**
+
+Future improvements include:
+
+- Improve the public API
+- Expand test coverage
+- Add more examples
+- Add embedding evaluation and visualization
+- Benchmark different training configurations
+- Publish the package to PyPI
+
+## References
+
+- [Efficient Estimation of Word Representations in Vector Space](https://arxiv.org/abs/1301.3781)
+- [Distributed Representations of Words and Phrases and their Compositionality](https://arxiv.org/abs/1310.4546)
+- [The Illustrated Word2Vec](https://jalammar.github.io/illustrated-word2vec/)
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer_pytorch.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/word2vec_trainer/__init__.py
+src/word2vec_trainer/dataset_loader.py
+src/word2vec_trainer/preprocessing.py
+src/word2vec_trainer/trainer.py
+src/word2vec_trainer/word2vec_model.py
+src/word2vec_trainer_pytorch.egg-info/PKG-INFO
+src/word2vec_trainer_pytorch.egg-info/SOURCES.txt
+src/word2vec_trainer_pytorch.egg-info/dependency_links.txt
+src/word2vec_trainer_pytorch.egg-info/requires.txt
+src/word2vec_trainer_pytorch.egg-info/top_level.txt
+tests/test_dataset.py
+tests/test_model.py
+tests/test_preprocessing.py
+tests/test_trainer.py

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer_pytorch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer_pytorch.egg-info/requires.txt

@@ -0,0 +1,6 @@
+torch>=2.0
+numpy>=1.24
+pandas>=2.0
+tqdm>=4.64
+matplotlib>=3.8.0
+pytest>=9.1.0

word2vec_trainer_pytorch-0.1.0/src/word2vec_trainer_pytorch.egg-info/top_level.txt

@@ -0,0 +1 @@
+word2vec_trainer

word2vec_trainer_pytorch-0.1.0/tests/test_dataset.py

@@ -0,0 +1,10 @@
+from word2vec_trainer.dataset_loader import DatasetLoader
+
+def test_dataset_loader():
+    dataset = DatasetLoader('tests/test_inputs/train_w2v.csv', 10, 'tests/test_inputs/neg_distribution_test.npy')
+
+    assert dataset.file_path == 'tests/test_inputs/train_w2v.csv'
+    with open('tests/test_inputs/train_w2v.csv', 'r') as f:
+        train_size = len(f.readlines()) - 1
+    assert dataset.__len__() == int(train_size * (1+dataset.neg_num))
+    

word2vec_trainer_pytorch-0.1.0/tests/test_model.py

@@ -0,0 +1,18 @@
+import torch
+from word2vec_trainer.word2vec_model import Word2Vec
+
+def test_shape():
+    model = Word2Vec(10, 10)
+    input_embeddings = model.state_dict()['input_embedding_layer.weight']
+    output_embeddings = model.state_dict()['output_embedding_layer.weight']
+
+    assert input_embeddings.shape == (10, 10)
+    assert output_embeddings.shape == (10, 10)    
+
+def test_forward():
+    model = Word2Vec(10, 10)
+    x = torch.tensor([[1], [0], [4]])
+    y = torch.tensor([[2], [4], [8]])
+    z = model(x, y)
+
+    assert z.shape == (3, 10)

word2vec_trainer_pytorch-0.1.0/tests/test_preprocessing.py

@@ -0,0 +1,20 @@
+import os
+from word2vec_trainer.preprocessing import Preprocessing
+
+def test_preprocessing():
+    preprocessor = Preprocessing('tests/test_inputs/example_data.txt',
+                                subsampled_file_path = 'tests/test_inputs/subsampled_data.txt',
+                                vocabulary_file = 'tests/test_inputs/vocabulary.csv',
+                                pos_example = 'tests/test_inputs/pos_examples.csv',
+                                train_path = 'tests/test_inputs/train_w2v.csv',
+                                valid_path = 'tests/test_inputs/valid_w2v.csv',
+                                test_path = 'tests/test_inputs/test_w2v.csv')
+    preprocessor.run()
+
+    assert os.path.exists(preprocessor.train_path) == True
+    assert os.path.exists(preprocessor.valid_path) == True
+    assert os.path.exists(preprocessor.test_path) == True
+    assert os.path.exists(preprocessor.subsampled_file_path) == True
+    assert os.path.exists(preprocessor.vocabulary_file) == True
+    assert os.path.exists(preprocessor.pos_examples) == True
+    

word2vec_trainer_pytorch-0.1.0/tests/test_trainer.py

@@ -0,0 +1,16 @@
+import os
+from word2vec_trainer.trainer import Trainer
+
+def test_trainer():
+    trainer = Trainer(
+        vocab_size = 10,
+        embedding_dim=2,
+        path_to_train='tests/test_inputs/train_w2v.csv',
+        path_to_val='tests/test_inputs/valid_w2v.csv',
+        path_to_neg_dist = 'tests/test_inputs/neg_distribution_test.npy',
+        epochs=10,
+        lr=0.01,
+        path_to_saved_model='tests/test_inputs/model.bin'
+    )
+
+    assert trainer.model != None