AventIQ-AI

DistilBERT Multilingual Language Identification Model for Chatbots This repository contains a fine-tuned `distilbert-base-multilingual-cased` transformer model for Language Identification (LangID) on the WiLI-2018 dataset. The model is optimized for use in multilingual chatbots, capable of identifying the language of user input across 200+ languages. The model is designed for multilingual chatbot applications, where automatic detection of user language is required to: - Route queries to appropriate NLP modules - Personalize responses in the user’s native language - Enable intelligent fallback to translation pipelines - Model Architecture: DistilBERT Multilingual (`distilbert-base-multilingual-cased`) - Task: Language Identification - Dataset: WiLI-2018 (Wikipedia Language Identification, 235 languages) - Fine-tuning Framework: Hugging Face Transformers - Input Format: A single sentence or user utterance - Output: ISO 639-3 language code - Accuracy: 0.965413 - F1 Score: 0.965528 - Precision: 0.966185 - Recall: 0.965413 - Source: Wikipedia articles - Languages: 235 ISO 639-3 codes - Samples per language: ~2,000 - Text Type: Encyclopedic, single-paragraph entries - Epochs: 3 - Batch size: 16 - Learning rate: 2e-5 - Max sequence length: 128 - Evaluation strategy: per epoch - Loss function: CrossEntropy - May have lower accuracy for extremely low-resource languages - Performance may degrade on noisy, code-switched, or informal text - Assumes input is a single-language sentence Contributions and improvements are welcome! Please open an issue or pull request if you'd like to help enhance this model or its documentation.

t5-small Quantized Model for Text Summarization on Reddit-TIFU dataset This repository hosts a quantized version of the t5-small model, fine-tuned for text summarization using the Reddit-TIFU dataset. The model has been optimized using FP16 quantization for efficient deployment without significant accuracy loss. - Model Architecture: t5-small(short version) - Task: Text generation - Dataset: Reddit-TIFU (Hugging Face Datasets) - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers - Rouge1: 19.590 - Rouge2: 4.270 - Rougel: 16.390 - Rougelsum: 16.800 The dataset is sourced from Hugging Face’s `Reddit-TIFU` dataset. It contains 79,000 reddit post and their summaries. The original training and testing sets were merged, shuffled, and re-split using an 90/10 ratio. - Epochs: 3 - Batch size: 8 - Learning rate: 2e-5 - Evaluation strategy: `epoch` Post-training quantization was applied using PyTorch’s `half()` precision (FP16) to reduce model size and inference time. - The model is trained specifically for text summarization on reddit posts - FP16 quantization may result in slight numerical instability in edge cases. Feel free to open issues or submit pull requests to improve the model or documentation.

This project fine-tunes a Sentence-BERT model (`paraphrase-MiniLM-L6-v2`) on the STS Benchmark English dataset (`stsbmultimt`) to perform semantic similarity scoring between two text inputs. 📊 Dataset - Dataset: stsbmultimt - Split: "en" - Purpose: Provides sentence pairs with similarity scores ranging from 0 to 5, which are normalized to 0–1 for training. 🏗️ Model Architecture ✅ Base Model - sentence-transformers/paraphrase-MiniLM-L6-v2 (from Hugging Face) ✅ Fine-Tuning - Cosine similarity computed between the CLS token embeddings of two inputs - Loss: Mean Squared Error (MSE) between predicted similarity and true score 📦text-similarity-project ┣ 📜similaritymodel.pt # Trained PyTorch model ┣ 📜trainingscript.py # Full training and inference script ┣ 📜README.md # Documentation

DistilBERT Base Uncased Quantized Model for Sentiment Analysis This repository hosts a quantized version of the DistilBERT model, fine-tuned for sentiment analysis tasks. The model has been optimized for efficient deployment while maintaining high accuracy, making it suitable for resource-constrained environments. - Model Architecture: DistilBERT Base Uncased - Task: Sentiment Analysis - Dataset: IMDB Reviews - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers - Accuracy: 0.56 - F1 Score: 0.56 - Precision: 0.68 - Recall: 0.56 The IMDb Reviews dataset was used, containing both positive and negative sentiment examples. - Number of epochs: 3 - Batch size: 16 - Evaluation strategy: epoch - Learning rate: 2e-5 Post-training quantization was applied using PyTorch's built-in quantization framework to reduce the model size and improve inference efficiency. - The model may not generalize well to domains outside the fine-tuning dataset. - Quantization may result in minor accuracy degradation compared to full-precision models. Contributions are welcome! Feel free to open an issue or submit a pull request if you have suggestions or improvements.

Text-to-Text Transfer Transformer Quantized Model for News Summarization This repository hosts a quantized version of the T5 model, fine-tuned specifically for text summarization of news. The model extracts concise summaries from semi-structured or unstructured news texts, making it ideal for POS systems, kitchen displays, and chat-based food order logging. - Field: Description - Model Architecture T5 (Text-to-Text Transfer Transformer) - Task Text Summarization for News - Input Format Free-form order text (includes Order ID, Customer, Items, etc.) - Quantization 8-bit (int8) using bitsandbytes - Framework Hugging Face Transformers - Base Model t5-base - Dataset Custom After fine-tuning the T5-Small model for text summarization, we obtained the following ROUGE scores: | Metric | Score | Meaning | |-------------|-----------|-------------| | ROUGE-1 | 0.4125 (~41%) | Overlap of unigrams between reference and summary. | | ROUGE-2 | 0.2167 (~22%) | Overlap of bigrams, indicating fluency. | | ROUGE-L | 0.3421 (~34%) | Longest common subsequence matching structure. | | ROUGE-Lsum | 0.3644 (~36%) | Sentence-level summarization effectiveness. | Custom-labeled food order dataset containing fields like Order ID, Customer, and Order Details. The model was trained to extract clean, natural summaries from noisy or inconsistent order formats. Post-training 8-bit quantization using bitsandbytes library with Hugging Face integration. This reduced the model size and improved inference speed with negligible impact on summarization quality. - The model may misinterpret or misformat input with excessive noise or missing key fields. - Quantized versions may show slight accuracy loss compared to full-precision models. - Best suited for English-language food order formats. Contributions are welcome! If you have suggestions, feature requests, or improvements, feel free to open an issue or submit a pull request.

Model Overview This is a Zero-shot Classification Model designed to classify the appropriate medical department or specialist a patient should consult based on their symptoms. The model is built using DistilBERT and trained for multi-class classification. Supported Classes: - Cardiology (Heart-related symptoms) - Neurology (Brain and nervous system issues) - Orthopedics (Bone and muscle problems) - Dermatology (Skin-related conditions) Training Data The model is trained on a curated dataset of patient symptoms and their corresponding medical specialties. The dataset includes textual descriptions of symptoms and their respective labels mapped to one of the four medical departments. The training data is collected from various medical sources, including: - Electronic Health Records (EHRs): Anonymized patient records detailing symptoms and diagnoses. - Medical Research Papers: Information extracted from clinical studies. - Expert-Labeled Datasets: Data manually classified by medical professionals. Preprocessing steps include: 1. Tokenization using DistilBERT’s tokenizer. 2. Stopword Removal to eliminate non-essential words. 3. Synonym Mapping to standardize medical terminology. 4. Class Balancing to ensure equal representation of all departments. Model Configuration - Architecture: DistilBERT for Sequence Classification - Hidden Dimension: 768 - Number of Layers: 6 - Attention Heads: 12 - Dropout: 0.1 - Maximum Token Length: 512 - Activation Function: GELU - Optimizer: AdamW - Batch Size: 16 - Epochs: 3 - Transformers Version: 4.48.3 How to Use the Model This model can be easily loaded and used with the Hugging Face `transformers` library. Model Files - model.safetensors: The trained model weights - config.json: Model configuration - tokenizerconfig.json: Tokenizer settings - specialtokensmap.json: Special tokens used in the model - vocab.txt: Vocabulary file for tokenization

BERT-Base-Uncased Fine-Tuned Model for Intent Classification on CLINC150 Dataset This repository hosts a fine-tuned BERT model for multi-class intent classification using the CLINC150 (plus) dataset. The model is trained to classify user queries into 150 in-scope intents and handle out-of-scope (OOS) queries. - Model Architecture: BERT Base Uncased - Task: Multi-class Intent Classification - Dataset: CLINC150 (plus variant) - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers - Accuracy: 0.947097 - Precision: 0.949821 - Recall: 0.947097 - F1 Score: 0.945876 The CLINC150 (plus) dataset contains 151 intent classes (150 in-scope + 1 out-of-scope) for intent classification in English utterances. It includes 15k training, 3k validation, and 4.5k test examples with diverse user queries. - Epochs: 5 - Batch size: 16 - Learning rate: 2e-5 - Evaluation strategy: `epoch` Post-training quantization was applied using PyTorch’s `half()` precision (FP16) to reduce model size and inference time. - The model is trained specifically for multi classification on CLINIC150 Dataset. - FP16 quantization may result in slight numerical instability in edge cases. Feel free to open issues or submit pull requests to improve the model or documentation.

This repository contains a BERT-based Named Entity Recognition (NER) model fine-tuned on the CoNLL-2003 dataset. The model is trained to identify common named entity types such as persons, organizations, locations, and miscellaneous entities. You can use this model for token classification to identify named entities in your text. - Dataset: CoNLL-2003, loaded via the Hugging Face datasets library - Evaluation: Performed on validation split (if applicable) - Quantization: Applied post-training for model size reduction (optional) - The model may not generalize well to unseen entity types or domains outside CoNLL-2003. - It can occasionally mislabel entities, especially for rare or new names. - A CUDA-enabled GPU is required for efficient training and inference.

This repository contains a quantized English-to-Chinese translation model fine-tuned on the ['wlhb/Transaltion-Chinese-2-English'] dataset and optimized using dynamic quantization for efficient CPU inference. - Base model: Helsinki-NLP/opus-mt-en-zh - Dataset: ['wlhb/Transaltion-Chinese-2-English'] - Training platform: Kaggle (CUDA GPU) - Fine-tuned: On English-Chinese pairs from the Hugging Face dataset - Quantization: PyTorch Dynamic Quantization (`torch.quantization.quantizedynamic`) - Tokenizer: Saved alongside the model quantizedmodel/ ├── config.json ├── pytorchmodel.bin ├── tokenizerconfig.json ├── tokenizer.json ├── vocab.json / merges.txt - Loaded dataset: wlhb/Transaltion-Chinese-2-English - Mapped translation data: {"en": ..., "zh": ...} before training - Quantization: torch.quantization.Quantizedynamic is used for efficient CPU inference

BERT-Base-Uncased Quantized Model for Sentiment Analysis for Trending Topic Sentiment This repository hosts a quantized version of the BERT model, fine-tuned for stock-market-analysis-sentiment-classification tasks. The model has been optimized for efficient deployment while maintaining high accuracy, making it suitable for resource-constrained environments. - Model Architecture: BERT Base Uncased - Task: Sentiment Analysis for Trending Topic Sentiment - Dataset: Stanford Sentiment Treebank v2 (SST2) - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers The dataset is taken from Kaggle Stanford Sentiment Treebank v2 (SST2). - Number of epochs: 3 - Batch size: 8 - Evaluation strategy: epoch - Learning rate: 2e-5 Post-training quantization was applied using PyTorch's built-in quantization framework to reduce the model size and improve inference efficiency. - The model may not generalize well to domains outside the fine-tuning dataset. - Quantization may result in minor accuracy degradation compared to full-precision models. Contributions are welcome! Feel free to open an issue or submit a pull request if you have suggestions or improvements.

RoBERTa-Base Quantized Model for Sentiment Analysis This repository hosts a quantized version of the RoBERTa model, fine-tuned for sentiment-analysis-twitter-tweets. The model has been optimized for efficient deployment while maintaining high accuracy, making it suitable for resource-constrained environments. - Model Architecture: RoBERTa Base - Task: Sentiment Analysis - Dataset: Twitter Sentiment Analysis - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers - Accuracy: 0.913237 - Precision: 0.913336 - Recall: 0.913568 - F1: 0.913237 Post-training quantization was applied using PyTorch's built-in quantization framework to reduce the model size and improve inference efficiency. - The model may not generalize well to domains outside the fine-tuning dataset. - Quantization may result in minor accuracy degradation compared to full-precision models. Contributions are welcome! Feel free to open an issue or submit a pull request if you have suggestions or improvements.

Sentence Transformer Quantized Model for Movie Recommendation on Movie-Lens-Dataset This repository hosts a quantized version of the Sentence Transformer model, fine-tuned for Movie Recommendation using the Movie Lens dataset. The model has been optimized using FP16 quantization for efficient deployment without significant accuracy loss. - Model Architecture: Sentence Transformer - Task: Movie Recommendation - Dataset: Movie Lens Dataset - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers The dataset is sourced from Hugging Face’s `Movie-Lens` dataset. It contains 20,000 movies and their genres. - Epochs: 2 - warmupsteps: 100 - showprogressbar: True - Evaluation strategy: `epoch` Post-training quantization was applied using PyTorch’s `half()` precision (FP16) to reduce model size and inference time. - The model is trained specifically for Movie Recommendation on Movies Dataset. - FP16 quantization may result in slight numerical instability in edge cases. Feel free to open issues or submit pull requests to improve the model or documentation.

Sentence-BERT Quantized Model for Text Similarity & Paraphrase Detection This repository hosts a quantized version of the Sentence-BERT (SBERT) model, fine-tuned on the Quora Question Pairs dataset for text similarity and paraphrase detection. The model computes semantic similarity between two input sentences and has been optimized for efficient deployment using ONNX quantization. - Model Architecture: Sentence-BERT (`all-MiniLM-L6-v2`) - Task: Text Similarity & Paraphrase Detection - Dataset: Quora Question Pairs (QQP) - Quantization: ONNX (Dynamic Quantization) - Fine-tuning Framework: Sentence-Transformers (Hugging Face) - Accuracy: ~0.87 - F1 Score: ~0.85 - Threshold for classification: 0.75 cosine similarity - Source: Quora Question Pairs (Kaggle) - Size: 400K+ question pairs labeled as paraphrase or not - Epochs: 3 - Batch Size: 16 - Evaluation Steps: 1000 - Warmup Steps: 1000 - Loss Function: CosineSimilarityLoss - Method: ONNX dynamic quantization - Tool: Hugging Face Optimum + ONNX Runtime - The cosine similarity threshold (0.75) may need tuning for different domains. - ONNX quantization may introduce slight performance degradation compared to full-precision models. - SBERT embeddings do not produce classification logits, only similarity scores. Contributions are welcome! Please open an issue or submit a pull request for bug fixes or improvements.

from transformers import AutoTokenizer, AutoModelForCausalLM import torch Set device device = "cuda" if torch.cuda.isavailable() else "cpu" Model and tokenizer modelname = "AventIQ-AI/gpt2-lmheadmodel-next-line-prediction-model" tokenizer = AutoTokenizer.frompretrained(modelname) model = AutoModelForCausalLM.frompretrained(modelname).to(device) Define test text sampletext = "Artificial intelligence is transforming" Tokenize input inputs = tokenizer(sampletext, returntensors="pt").to(device) Generate prediction with torch.nograd(): outputtokens = model.generate( inputs, maxlength=50, numbeams=5, repetitionpenalty=1.5, temperature=0.7, topk=50, topp=0.9, dosample=True, norepeatngramsize=2, numreturnsequences=1, earlystopping=True, lengthpenalty=1.0, padtokenid=tokenizer.eostokenid, eostokenid=tokenizer.eostokenid, returndictingenerate=True, outputscores=True ) Decode and clean response generatedresponse = tokenizer.decode(outputtokens.sequences[0], skipspecialtokens=True) cleanedresponse = html.unescape(generatedresponse).replace("#39;", "'").replace("quot;", '"') This repository hosts a fine-tuned GPT-2 model optimized for next-line prediction tasks. The model has been fine-tuned on the OpenWebText dataset and quantized in FP16 format to enhance efficiency without compromising performance. - Model Architecture: GPT-2 (Causal Language Model) - Task: Next-line Prediction - Dataset: OpenWebText (subset: `stas/openwebtext-10k`) - Quantization: FP16 for reduced model size and faster inference - Fine-tuning Framework: Hugging Face Transformers - Number of Epochs: 3 - Batch Size: 4 - Evaluation Strategy: Epoch - Learning Rate: 5e-5 Evaluation Metrics (Perplexity Score) Perplexity Score: 14.355693817138672 - The model is optimized for English-language next-word prediction tasks. - While quantization improves speed, minor accuracy degradation may occur. - Performance on out-of-distribution text (e.g., highly technical or domain-specific data) may be limited. Contributions are welcome! Feel free to open an issue or submit a pull request if you have suggestions or improvements.

Model Card: t5-summary-finetuned-kw-fp16 Model Overview - Model Name: t5-summary-finetuned-kw-fp16 - Base Model: T5-base (t5-base from Hugging Face) - Date: March 19, 2025 - Version: 1.0 - Task: Keyword-Based Text Summarization - Description: A fine-tuned T5-base model quantized to FP16 for generating concise summaries from short text inputs, guided by a user-specified keyword. Trained on a custom dataset of 200 examples, it produces summaries focusing on the keyword while maintaining a professional tone. Model Details - Architecture: Encoder-Decoder Transformer (T5-base) - Parameters: ~223M (original T5-base), quantized to FP16 - Precision: FP16 (16-bit floating-point) - Input Format: Text paragraph + "Keyword: [keyword]" (e.g., "The storm caused heavy rain and wind damage. Keyword: rain") - Output Format: Concise summary (1-2 sentences) focusing on the keyword (e.g., "The storm brought heavy rain overnight.") - Training Hardware: NVIDIA GPU with 12 GB VRAM (e.g., RTX 3060) - Inference Hardware: Compatible with GPUs supporting FP16 (minimum ~1.5 GB VRAM) Training Data Dataset Name: Custom Keyword-Based Summarization Dataset - Size: 200 examples - Split: 180 training, 20 validation - Format: CSV - input: Paragraph (2-4 sentences) + "Keyword: [keyword]" - keyword: Single word or short phrase guiding the summary - output: Target summary (1-2 sentences) - Content: Diverse topics including tech, weather, sports, health, and culture (e.g., "A new laptop was released with a fast processor... Keyword: processor" → "The new laptop has a fast processor.") - Language: English Training Procedure - Framework: PyTorch via Hugging Face Transformers Hyperparameters: Epochs: 2 (stopped early; originally set for 3) - Learning Rate: 3e-4 - Batch Size: 4 (effective 8 with gradient accumulation) - Warmup Steps: 5 - Weight Decay: 0.01 - Precision: FP16 (mixed precision training) - Training Time: ~1.5 minutes on a 12 GB GPU Loss: - Training: 1.0099 (epoch 1) → 0.3479 (epoch 2) - Validation: 1.0176 (epoch 1, best) → 1.0491 (epoch 2) Performance - Metrics: Validation loss (best: 1.0176) - Qualitative Evaluation: Generates concise, keyword-focused summaries with good coherence (e.g., "The concert featured a famous singer" for keyword "singer"). Intended Use - Purpose: Summarize short texts (e.g., news snippets, reports) based on a user-specified keyword. - Use Case: Quick summarization for journalists, researchers, or content creators needing keyword-driven insights. - Out of Scope: Not designed for long documents (>128 tokens) or abstractive summarization without keywords. Usage Instructions

T5-Small for News Headline Generation This is a T5-Small model fine-tuned for generating concise and informative news topics from content summaries. It is useful for news agencies, content creators, and media professionals to generate headlines efficiently. Model Details Model Type: Sequence-to-Sequence Transformer Base Model: t5-small Maximum Sequence Length: 128 tokens (input and output) Output: News headlines based on input summaries Task: Text Summarization (Headline Generation) Model Sources Documentation: T5 Model Documentation Repository: Hugging Face Model Hub Hugging Face Model: Available on Hugging Face Training Details Training Dataset Dataset Name: News Headlines Dataset Size: 30,000 rows Columns: articlesummary (input), headline (output) Training Hyperparameters - perdevicetrainbatchsize: 8 - perdeviceevalbatchsize: 8 - gradientaccumulationsteps: 2 - numtrainepochs: 4 - learningrate: 5e-5 - fp16: True This model is optimized for content topic generation, ensuring concise, accurate, and informative outputs. 🚀

RoBERTa-Base Quantized Model for Topic Classification This repository hosts a quantized version of the RoBERTa model, fine-tuned for topic classification using the AG News dataset. The model has been optimized using FP16 quantization for efficient deployment without significant accuracy loss. Model Details - Model Architecture: RoBERTa Base - Task: Multi-class Topic Classification (4 classes) - Dataset: AG News (Hugging Face Datasets) - Quantization: Float16 - Fine-tuning Framework: Hugging Face Transformers - Accuracy: 0.9471 - Precision: 0.9471 - Recall: 0.9471 - F1 Score: 0.9471 The dataset is sourced from Hugging Face’s agnews dataset. It contains 120,000 training samples and 7,600 test samples, with each news article labeled into one of four categories: World, Sports, Business, or Sci/Tech. The original dataset was used as provided, and input texts were tokenized using the RoBERTa tokenizer and truncated/padded to a maximum length of 128 tokens. - Epochs: 3 - Batch size: 8 - Learning rate: 2e-5 - Evaluation strategy: `epoch` Post-training quantization was applied using PyTorch’s `half()` precision (FP16) to reduce model size and inference time. - The model is trained specifically for binary topic classification on ag news dataset. - FP16 quantization may result in slight numerical instability in edge cases. Feel free to open issues or submit pull requests to improve the model or documentation.

This repository contains a Vision Transformer (ViT)-based AI model fine-tuned for image classification on the CIFAR-100 dataset. The model is built using `google/vit-base-patch16-224`, quantized to FP16 for efficient inference, and delivers high accuracy in multi-class image classification tasks. - Description: CIFAR-100 is a dataset of 60,000 32×32 color images in 100 classes (600 images per class) - Split: 50,000 training images and 10,000 test images - Categories: Animals, Vehicles, Food, Household items, etc. - License: MIT License (from source) - Inference Speed: Significantly faster after quantizationextractor = ViTFeatureExtractor.frompretrained("google/vit-base-patch16-224") 📦image-classification-vit ┣ 📂vit-cifar100-fp16 ┣ 📜train.py ┣ 📜inference.py ┣ 📜README.md ┗ 📜requirements.txt