A Hybrid Stacked Bidirectional Long Short-Term Memory (BiLSTM + LSTM) Framework for Context-Aware Next-Word and Sequence Generation
-purple.svg){kind=icon}
Predictive Text Generation is a core subfield of Natural Language Generation (NLG) and Natural Language Processing (NLP) that models the probabilistic sequence distribution of human language to anticipate subsequent tokens given an antecedent seed context. While traditional autocompletion systems rely heavily on frequency-based statistical
This repository hosts the official implementation and research artifacts for the peer-reviewed study:
"Next Word Prediction Using Deep Learning Approach" (published in NeuroQuantology, Vol. 20, Issue 11, 2022).
The proposed solution introduces a Stacked Bidirectional Long Short-Term Memory (BiLSTM + LSTM) neural architecture combined with word-level dense vector embeddings, dropout regularization, and a dense representation bottleneck. Trained on over 23,140 input subsequences, the framework achieves 91.32% categorical accuracy and a minimal cross-entropy loss of 0.2614, substantially outperforming conventional unidirectional LSTM baselines (~72.0–74.0%). The architecture is paired with an interactive Flask-powered web text editor enabling real-time, low-latency autocompletion and dynamic multi-word iterative sequence generation.
If you utilize this codebase, model architecture, or research findings in your academic work, projects, or publications, please cite the original peer-reviewed paper:
Himani Dighorikar, Shridhar Ashtikar, Ishika Bajaj, Shivam Gupta, and Dilipkumar A. Borikar.
"NEXT WORD PREDICTION USING DEEP LEARNING APPROACH."
NeuroQuantology, Volume 20, Issue 11, September 2022, pp. 247-253.
DOI: 10.14704/NQ.2022.20.11.NQ66027
| Field | Details |
|---|---|
| Paper Title | NEXT WORD PREDICTION USING DEEP LEARNING APPROACH |
| Authors | Himani Dighorikar, Shridhar Ashtikar, Ishika Bajaj, Shivam Gupta, Prof. Dilipkumar A. Borikar |
| Affiliation | Department of Computer Science and Engineering, Shri Ramdeobaba College of Engineering and Management (RCOEM), Nagpur, Maharashtra, India |
| Journal | NeuroQuantology (An Interdisciplinary Journal of Neuroscience and Quantum Physics) |
| ISSN | eISSN 1303-5150 |
| Volume / Issue | Volume 20, Issue 11, September 2022 |
| Pagination | pp. 247 – 253 |
| DOI | 10.14704/NQ.2022.20.11.NQ66027 |
| Direct Paper URL | https://doi.org/10.14704/NQ.2022.20.11.NQ66027 |
| Project Thesis | Bachelor of Engineering Thesis in CSE, RCOEM (Affiliated to RTM Nagpur University), May 2022 |
@article{dighorikar2022next,
title = {NEXT WORD PREDICTION USING DEEP LEARNING APPROACH},
author = {Dighorikar, Himani and Ashtikar, Shridhar and Bajaj, Ishika and Gupta, Shivam and Borikar, Dilipkumar A.},
journal = {NeuroQuantology},
volume = {20},
number = {11},
pages = {247--253},
month = {September},
year = {2022},
issn = {1303-5150},
doi = {10.14704/NQ.2022.20.11.NQ66027},
url = {https://doi.org/10.14704/NQ.2022.20.11.NQ66027}
}In modern digital productivity environments—including IDEs, email clients, content writing editors, and mobile virtual keyboards—manual text composition constitutes a repetitive, time-intensive bottleneck. Real-time predictive text systems mitigate user typing effort, reduce typographical and grammatical errors, and accelerate textual input rates. Furthermore, predictive text is a crucial accessibility technology for individuals with motor disabilities using Augmentative and Alternative Communication (AAC) devices.
PARADIGM EVOLUTION
[ Statistical N-Gram Models ] --> Sparse tables, exponential memory explosion, no semantic context.
│
[ Standard Recurrent NN ] --> Solved sequential order, but suffered from Vanishing Gradients.
│
[ Vanilla Forward LSTM ] --> Solved long-term memory, but unidirectional (unaware of future context).
│
[ Proposed Stacked BiLSTM ] --> FULL BIDIRECTIONAL CONTEXT + DENSE BOTTLENECK (91.32% Accuracy)
-
Statistical
$N$ -Gram & Markovian Approaches:- Suffer from the curse of dimensionality: the state space grows exponentially as
$\mathcal{O}(|V|^N)$ , making$N > 3$ computationally intractable. - Zero-probability problem on out-of-vocabulary or unseen
$n$ -grams, requiring heuristic smoothing (e.g., Kneser-Ney, Good-Turing). - Inability to encode semantic similarities (e.g., treating
"doctor"and"physician"as completely independent orthogonal indices).
- Suffer from the curse of dimensionality: the state space grows exponentially as
-
Vanilla Recurrent Neural Networks (RNNs):
- Suffer from vanishing and exploding gradients when backpropagating through long sequences (
$\frac{\partial L}{\partial h_1} \to 0$ ), preventing retention of information beyond 5–10 time steps.
- Suffer from vanishing and exploding gradients when backpropagating through long sequences (
-
Unidirectional LSTMs:
- While gating mechanisms (input, forget, output gates) alleviate vanishing gradients, standard LSTMs process text strictly left-to-right (
$\overrightarrow{h}_t$ ). - Consequently, they fail to resolve lexical polysemy and homographs where preceding ambiguity is resolved by structural context (e.g., distinguishing "Apple is something that competitors cannot reproduce" vs. "Apple is something that I like to eat").
- While gating mechanisms (input, forget, output gates) alleviate vanishing gradients, standard LSTMs process text strictly left-to-right (
The proposed architecture integrates:
- A continuous 100-dimensional Word Embedding Layer mapping discrete token IDs into dense semantic vector space.
- A Bidirectional LSTM Layer (150 units
$\times 2 = 300$ hidden states) that scans input sequences simultaneously in forward ($\overrightarrow{h}_t$ ) and backward ($\overleftarrow{h}_t$ ) directions. - A Spatial Dropout Regularizer (
$p=0.20$ ) preventing co-adaptation of hidden feature extractors. - A Unidirectional LSTM Layer (100 units) synthesizing temporal dependencies into a unified recurrent representation.
- A Dense Bottleneck Layer (
$|V| / 2 = 1,611$ units with ReLU activation) followed by a Softmax Classifier ($|V| = 3,222$ units) generating a normalized probability distribution$P(w_{t} \mid w_{1:t-1})$ over the full vocabulary.
- 🧠 Stacked Bidirectional Architecture: Synthesizes both past and future contextual dependencies through 150-unit BiLSTM and 100-unit LSTM layers.
- 📈 State-of-the-Art Sequence Accuracy: Achieves 91.32% accuracy and 0.2614 loss on literary corpus benchmarks after 100 epochs, beating standard LSTM baselines by +17.32%.
- ⚡ Sub-Millisecond Inference: Highly optimized matrix transformations executing token inference in
$<1.5\text{ ms}$ on standard CPU/GPU runtimes. - 🔁 Dual Prediction Modes:
- Greedy Top-1 Autocomplete: Instant next-word recommendation for interactive keystroke typing.
- Iterative Multi-Token Rolling Generation: Recursively feeds predicted tokens into seed contexts to generate coherent multi-word phrases and sentences.
- 🛡️ Regularization & Generalization: Incorporates
$20%$ dropout and intermediate dimensional reduction ($|V| \to |V|/2 \to |V|$ ) to prevent overfitting on long-tail vocabularies. - 🌐 Full-Stack Web Text Editor: Integrated Flask microservice featuring user authentication (sign-up/login), real-time suggestion overlays, and interactive text composition.
- 📦 End-to-End Self-Contained Pipeline: Complete data extraction, regex cleaning, tokenization, sequence padding, one-hot target encoding, JSON model weight persistence, and inference loading.
flowchart TD
subgraph Data_Pipeline ["1. Data Ingestion & Preprocessing"]
A["Raw Text Corpus<br/>(Metamorphosis.txt / Harry Potter)"] --> B["Text Cleaning & Normalization<br/>(Lowercasing, Regex Filtering, Newline Splitting)"]
B --> C["Keras Tokenizer<br/>(Vocabulary Mapping V = 3,222)"]
C --> D["N-Gram Subsequence Generator<br/>(23,144 Cumulative Sequences)"]
D --> E["Pre-Sequence Zero Padding<br/>(Max Sequence Length = 18)"]
E --> F["Feature & Target Splitting<br/>X: (23144, 17) | y: (23144, 3222) One-Hot"]
end
subgraph Deep_Learning_Model ["2. Deep Neural Network Architecture"]
F --> G["Embedding Layer<br/>(Input: 17, Dim: 100, Params: 322,200)"]
G --> H["Bidirectional LSTM Layer<br/>(150 Units Forward + 150 Units Backward)"]
H --> I["Dropout Regularization<br/>(Rate = 0.20)"]
I --> J["Unidirectional LSTM Layer<br/>(100 Units, Temporal Aggregation)"]
J --> K["Dense Hidden Layer<br/>(1,611 Neurons, ReLU Activation)"]
K --> L["Dense Output Layer<br/>(3,222 Neurons, Softmax Activation)"]
end
subgraph Training_Optimization ["3. Optimization & Persistence"]
L --> M["Loss: Categorical Crossentropy<br/>Optimizer: Adam (lr=0.001)"]
M --> N["Trained Weights & Topology Export<br/>(model_bilstm.json + model_bilstm.h5)"]
end
subgraph Inference_Deployment ["4. Inference Engine & Web Application"]
O["User Input Seed Text<br/>'Gregor slowly pushed his'"] --> P["Tokenize & Pad Sequence"]
N --> Q["Loaded BiLSTM Engine"]
P --> Q
Q --> R["Softmax Probability Vector P(w_t | context)"]
R --> S["Argmax / Top-K Decoding<br/>Next Word: 'way'"]
S --> T["Flask REST API Backend"]
T --> U["Interactive Web Text Editor UI<br/>(Real-Time Autocomplete & User Dashboard)"]
end
style Data_Pipeline fill:#f0f4f8,stroke:#2b6cb0,stroke-width:2px;
style Deep_Learning_Model fill:#edf2f7,stroke:#2c5282,stroke-width:2px;
style Training_Optimization fill:#feebc8,stroke:#c05621,stroke-width:2px;
style Inference_Deployment fill:#e6fffa,stroke:#234e52,stroke-width:2px;
For each time step
Where
The forward and backward LSTM hidden vectors are concatenated at each time step
The final recurrent representation
The network is optimized by minimizing Categorical Cross-Entropy Loss:
| Layer Index | Layer Type | Output Shape | Parameters | Activation | Purpose / Description |
|---|---|---|---|---|---|
| 0 | Input Layer | (None, 17) |
0 | — | Padded token sequence indices ( |
| 1 | Embedding | (None, 17, 100) |
Linear | Maps |
|
| 2 | Bidirectional(LSTM) | (None, 17, 300) |
Tanh / Sigmoid | 150 forward + 150 backward units with return_sequences=True
|
|
| 3 | Dropout | (None, 17, 300) |
0 | — |
|
| 4 | LSTM | (None, 100) |
Tanh / Sigmoid | 100-unit temporal aggregation returning final state | |
| 5 | Dense (Bottleneck) | (None, 1611) |
ReLU | Intermediate non-linear dimensionality compression ($ | |
| 6 | Dense (Output) | (None, 3222) |
Softmax | Normalized categorical probability distribution over $ | |
| Total | Full Architecture | — | — | Trainable Parameters: 6,137,153 (23.41 MB) |
The primary training benchmark uses the literary classic The Metamorphosis by Franz Kafka (Project Gutenberg) and multi-domain comparative narrative corpora (including Harry Potter text segments). The text exhibits rich sentence structures, diverse lexical choices, and strong syntactic dependencies ideal for evaluating language modeling accuracy.
Input Line: "friendly laugh that made her unable to speak straight away"
│
▼ [ Tokenization & Indexing ]
Dictionary Map: {'friendly': 112, 'laugh': 89, 'that': 12, 'made': 90, 'her': 14, 'unable': 15, 'to': 10, 'speak': 55, ...}
│
▼ [ N-Gram Subsequence Extraction ]
Sequence 1: [112, 89]
Sequence 2: [112, 89, 12]
Sequence 3: [112, 89, 12, 90]
...
Sequence N: [112, 89, 12, 90, 14, 15, 10, 55]
│
▼ [ Pre-Padding to Max Length L = 18 ]
Padded Vector: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 112, 89, 12, 90, 14, 15, 10, 55]
│
▼ [ Feature (X) vs Target (y) Partitioning ]
Input X (17 tokens): [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 112, 89, 12, 90, 14, 15, 10]
Target y (1 token): [55] ──► One-Hot Encoded Vector y ∈ {0, 1}^3222
| Attribute | Quantitative Value | Description |
|---|---|---|
| Total Lines in Corpus | 2,221 |
Raw line segments extracted from corpus |
| Total Extracted Sequences | 23,144 |
Cumulative |
| **Vocabulary Size ($ | V | $)** |
| Max Sequence Length ( |
18 |
Maximum sequence depth across the entire corpus |
| Feature Tensor |
(23144, 17) |
Context input matrix with zero pre-padding |
| Target Tensor |
(23144, 3222) |
One-hot encoded ground truth token distributions |
| Embedding Dimensions | 100 |
Dense vector representation per token |
Experiments were conducted comparing traditional statistical methods, standard recurrent neural networks, unidirectional LSTMs, and the proposed Stacked BiLSTM architecture:
| Model Architecture | Context Horizon | Trainable Params | Convergence Epochs | Training Loss ( |
Prediction Accuracy |
|---|---|---|---|---|---|
| Higher-Order N-Gram (Assamese/English) | — | — | — | ||
| Naive Bayes + Latent Semantic Analysis | Bag-of-Words | — | — | — | |
| Standard Recurrent Neural Network (RNN) | 5 tokens | 50 | |||
| Unidirectional LSTM (Baseline) | 17 tokens | 25 | |||
| Unidirectional LSTM (Extended) | 17 tokens | 50 | |||
| BiLSTM (Paper Evaluation) | 17 tokens | 75 | |||
| Proposed Stacked BiLSTM + LSTM (Final) | 17 tokens | 100 | 91.32% |
Key Observation: The proposed Stacked BiLSTM achieves a +17.32% absolute accuracy gain over standard LSTM baselines due to its bidirectional context modeling and dense ReLU representation bottleneck.
Accuracy (%) ── Epoch Progression
100% ┼────────────────────────────────────────────────────────────╭───────── 91.32%
80% ┼─────────────────────────────────────────────╭──────────────╯
60% ┼──────────────────────────────╭──────────────╯
40% ┼──────────────╭───────────────╯
20% ┼──╭───────────╯
0% ┴──┴───────────┴───────────────┴───────────────┴───────────────┴─────────
Epoch 1 Epoch 25 Epoch 50 Epoch 75 Epoch 100
| Epoch Milestone | Training Loss ( |
Categorical Accuracy | Epoch Duration | Learning Dynamics / Remarks |
|---|---|---|---|---|
| Epoch 1 | 6.2669 |
5.56% |
Uniform weight initialization; high initial perplexity | |
| Epoch 10 | 4.1120 |
24.80% |
Rapid convergence on high-frequency stop words (the, to, and) |
|
| Epoch 25 | 1.4250 |
74.00% |
Surpasses baseline unidirectional LSTM accuracy | |
| Epoch 50 | 0.3832 |
88.32% |
Stabilizes grammatical agreements and syntactic clauses | |
| Epoch 75 | 0.2997 |
90.31% |
Fine-grained resolution of long-range contextual references | |
| Epoch 100 | 0.2614 |
91.32% |
Optimal convergence; zero gradient explosion; minimal cross-entropy |
Below are actual sequence predictions generated by the trained model given arbitrary seed inputs:
| # | Seed Prompt ( |
Model Predicted Next Words | Generated Complete Sentence | Context Quality |
|---|---|---|---|---|
| 1 | "Gregor slowly pushed his" |
way over to the door with |
"Gregor slowly pushed his way over to the door with" | ⭐⭐⭐⭐⭐ (Fluent) |
| 2 | "If he succeeded in falling out of" |
bed in this way |
"If he succeeded in falling out of bed in this way" | ⭐⭐⭐⭐⭐ (Fluent) |
| 3 | "The first response to his" |
situation had been new but that |
"The first response to his situation had been new but that he had heard the door" | ⭐⭐⭐⭐⭐ (Fluent) |
| 4 | "After a while he had already" |
moved so far across that it |
"After a while he had already moved so far across that it would have been more" | ⭐⭐⭐⭐⭐ (Fluent) |
| 5 | "He began running" |
a broom but then he stood |
"He began running a broom but then he stood" | ⭐⭐⭐⭐ (Narrative) |
| 6 | "But I understand that" |
was a doorway |
"But I understand that was a doorway" | ⭐⭐⭐⭐ (Syntactic) |
| 7 | "He seemed disappointed" |
when the |
"He seemed disappointed when the" | ⭐⭐⭐⭐⭐ (Fluent) |
predictive-text-generation-main/
│
├── 📓 BiLSTM.ipynb # Initial exploratory notebook (BiLSTM prototyping & training)
├── 📓 Final Model.ipynb # Production notebook: complete training (100 epochs),
│ # topology export (JSON + H5), and interactive prediction engine
│
├── 📄 Next Word Prediction Using Deep Learning Approach.pdf # Official published research paper (NeuroQuantology 2022)
├── 📄 Project Report - Predictive Text Generation.pdf # Comprehensive Bachelor of Engineering Thesis Report (40+ pages)
│
├── 📄 README.md # Research-grade project documentation & citation guide
└── 📄 LICENSE # Open-source software license (MIT)
-
Final Model.ipynb: Contains the end-to-end pipeline: tokenization, vocabulary mapping ($V=3222$ ), n-gram generation ($N=23144$ ), model construction (Embedding+BiLSTM(150)+Dropout(0.2)+LSTM(100)+Dense(1611)+Dense(3222)), 100-epoch training loop, model serialization (model_bilstm.json,model_bilstm.h5), and top-1 / top-$K$ sequence generation. -
BiLSTM.ipynb: Contains comparative experiments, visualization utilities (matplotlibtraining curves), and sequence sampling methods. -
Next Word Prediction Using Deep Learning Approach.pdf: Peer-reviewed research article detailing theoretical foundations, literature survey, empirical benchmarks, and comparative findings. -
Project Report - Predictive Text Generation.pdf: Complete academic thesis covering full system design, hardware/software specifications, Flask web architecture, and full UI screenshots.
-
Python: Version
3.8,3.9,3.10, or3.11 -
Hardware: CPU (Intel i5/i7/Ryzen) with
$\ge 8\text{ GB RAM}$ ; NVIDIA CUDA GPU recommended for fast training. - Operating System: Windows 10/11, Ubuntu 20.04+, or macOS.
Clone the repository and create an isolated Python virtual environment:
# Clone repository
git clone https://github.com/shivamm-gupta/Predictive-Text-generation.git
cd Predictive-Text-generation
# Create and activate virtual environment
python -m venv venv
# On Windows (PowerShell):
venv\Scripts\Activate.ps1
# On Linux/macOS:
source venv/bin/activate
# Upgrade pip and install core deep learning dependencies
pip install --upgrade pip
pip install tensorflow numpy pandas matplotlib nltk flask jupyterLaunch Jupyter Lab / Notebook to run the pipeline interactively:
jupyter notebook "Final Model.ipynb"- Run Cells 1–6 to ingest the corpus, compute n-gram sequences, pad matrices, and instantiate the model.
- Run Cell 7 to execute the 100-epoch training loop (
model.fit(X, y, epochs=100)). - Run Cells 13–14 to serialize the architecture to
model_bilstm.jsonand weights tomodel_bilstm.h5. - Run Cell 16 to execute interactive real-time text predictions.
You can directly load the trained model and generate predictions with this standalone Python snippet:
import json
import numpy as np
from tensorflow.keras.models import model_from_json
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
def load_predictive_system(model_json_path, weights_path, corpus_path):
# 1. Rebuild corpus tokenizer
with open(corpus_path, "r", encoding="utf-8") as f:
corpus = f.read().lower().split("\n")
tokenizer = Tokenizer()
tokenizer.fit_on_texts(corpus)
# 2. Load model topology & weights
with open(model_json_path, "r") as f:
model = model_from_json(f.read())
model.load_weights(weights_path)
print("✅ Model successfully loaded from disk.")
return model, tokenizer
def predict_next_words(model, tokenizer, seed_text, max_sequence_len=18, num_words=5):
current_text = seed_text
print(f"\nPrompt: '{seed_text}'")
for step in range(num_words):
tokens = tokenizer.texts_to_sequences([current_text])[0]
padded_tokens = pad_sequences([tokens], maxlen=max_sequence_len-1, padding="pre")
predictions = model.predict(padded_tokens, verbose=0)
predicted_idx = np.argmax(predictions, axis=-1)[0]
predicted_word = tokenizer.index_word.get(predicted_idx, "")
if not predicted_word:
break
print(f" Step {step+1}: Suggested next token ──► '{predicted_word}'")
current_text += " " + predicted_word
print(f"Resulting Sentence: '{current_text}'\n")
return current_text
# Example Execution
if __name__ == "__main__":
# Ensure model files exist
# model, tokenizer = load_predictive_system("model_bilstm.json", "model_bilstm.h5", "Metamorphosis.txt")
# predict_next_words(model, tokenizer, seed_text="Gregor slowly pushed his", num_words=6)
passThe project report outlines an interactive web editor powered by Flask. Below is the production API design:
from flask import Flask, request, jsonify, render_template
import numpy as np
app = Flask(__name__)
@app.route("/api/predict", methods=["POST"])
def api_predict():
data = request.get_json(force=True)
seed = data.get("seed_text", "")
top_k = int(data.get("top_k", 3))
if not seed.strip():
return jsonify({"success": False, "error": "Empty seed text"}), 400
tokens = tokenizer.texts_to_sequences([seed.lower()])[0]
padded = pad_sequences([tokens], maxlen=17, padding="pre")
probs = model.predict(padded, verbose=0)[0]
# Top-K candidate extraction
top_indices = np.argsort(probs)[-top_k:][::-1]
suggestions = [
{"word": tokenizer.index_word.get(idx, ""), "probability": float(probs[idx])}
for idx in top_indices if idx in tokenizer.index_word
]
return jsonify({
"success": True,
"seed_text": seed,
"suggestions": suggestions
})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=False)- Transformer & Attention-Based Adaptation:
- Integrate Self-Attention heads and fine-tune lightweight decoder-only architectures (e.g., GPT-2, MiniLLaMA, DistilGPT) for richer semantic abstraction across multi-paragraph spans.
- Edge & Client-Side Zero-Latency Inference:
- Quantize the BiLSTM model into TensorFlow Lite (TFLite) and ONNX formats, compiling for WebAssembly /
transformers.jsto run 100% offline inside browsers and mobile keyboards with zero server overhead.
- Quantize the BiLSTM model into TensorFlow Lite (TFLite) and ONNX formats, compiling for WebAssembly /
- Dynamic Online Vocabulary Learning:
- Implement continuous online vocabulary expansion using trie-based memory caches to learn user-specific slang, named entities, and typing cadence without full retraining.
- Assistive Communication (AAC) Hardware Integration:
- Interface the model with eye-tracking or single-switch assistive communication keyboards to dramatically reduce physical input strain for users with ALS or cerebral palsy.
- Multilingual & Polyglot Modeling:
- Expand the tokenizer and recurrent architecture to low-resource Indic languages (Hindi, Marathi, Assamese) using subword byte-pair encoding (BPE).
- Himani Dighorikar — Department of Computer Science & Engineering, RCOEM (
dighorikarhm@rknec.edu) - Shridhar Ashtikar — Department of Computer Science & Engineering, RCOEM (
ashtikarsa@rknec.edu) - Ishika Bajaj — Department of Computer Science & Engineering, RCOEM (
bajajij@rknec.edu) - Shivam Gupta — Department of Computer Science & Engineering, RCOEM (
guptasb_1@rknec.edu)
- Prof. Dilipkumar A. Borikar — Assistant Professor, Department of Computer Science & Engineering, Shri Ramdeobaba College of Engineering and Management, Nagpur (
borikarda@rknec.edu)
- Dr. Avinash Agrawal — Head of Department (H.O.D.), Computer Science and Engineering, RCOEM
- Dr. R. S. Pande — Principal, Shri Ramdeobaba College of Engineering and Management, Nagpur
- Department of Computer Science and Engineering
Shri Ramdeobaba College of Engineering and Management (RCOEM)
(An Autonomous Institute affiliated to Rashtrasant Tukadoji Maharaj Nagpur University, Nagpur, Maharashtra, India - 440013)
Special thanks to the High-Performance Computing and Deep Learning Research Laboratory in the Department of Computer Science and Engineering at RCOEM for providing computational infrastructure, GPU resources, and research guidance throughout the execution of this project.
This project and its associated source code are distributed under the MIT License. The research paper and thesis documents are published under academic copyright agreements (NeuroQuantology / RCOEM).
MIT License
Copyright (c) 2022 Himani Dighorikar, Shridhar Ashtikar, Ishika Bajaj, Shivam Gupta, Dilipkumar A. Borikar
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.
⭐ If you find this research and repository helpful, please consider starring the repository! ⭐