sentiment-analyzer

Ultra-Lightweight Sentiment Analyzer Welcome to the repository for the ultra-lightweight, real-time sentiment analysis model designed specifically for mobile applications. This model brings the power of BERT's transformer architecture to a form that's optimized for performance on mobile devices.

Model Details Architecture: DistilBERT, a distilled version of the BERT model known for its balance between performance and efficiency. Training Data: The model has been trained on a diverse semantic dataset, ensuring a robust understanding of language nuances. Quantization: Post-training dynamic quantization is applied to reduce model size without a significant reduction in accuracy, making it ideal for on-device deployment. Size: Approximately 130 MB, optimized for mobile environments. Latency: Achieves real-time inference on mobile devices with reduced latency. Usage This model can be used directly for sentiment analysis tasks or further fine-tuned on domain-specific datasets. It's perfect for applications where quick, on-the-fly text analysis is needed, such as live customer feedback analysis or on-device content moderation.

python Copy code from transformers import pipeline

Load the sentiment analysis pipeline

sentiment_pipeline = pipeline("sentiment-analysis", model="YOUR_MODEL_NAME")

Analyze sentiment

result = sentiment_pipeline("I love using this mobile app, it's so fast and easy!") print(result) Applications The sentiment analyzer is suited for a variety of real-world applications:

Customer Feedback Analysis: Quickly determine sentiment in user feedback or reviews. Content Moderation: Maintain community guidelines by filtering inappropriate content in real-time. Market Research: Analyze survey responses or social media posts to extract actionable insights. Compliance Monitoring: Ensure communications adhere to industry regulations. Performance Metrics Refer to the attached performance graphs to understand the model's efficiency gains through quantization. The graphs illustrate latency improvements and training versus validation loss, showcasing the model's reliability and speed.

How to Contribute Contributions to improve the model or expand its use cases are welcome. Please follow the contribution guidelines outlined in CONTRIBUTING.md.

License This model is open-source and available under the MIT license, allowing for commercial and private use, modification, and distribution.

Acknowledgements

example usecase....

Install required libraries

!pip install transformers torch import torch from transformers import DistilBertTokenizer, DistilBertForSequenceClassification from google.colab import files uploaded = files.upload() tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased') import torch from transformers import DistilBertTokenizer, DistilBertForSequenceClassification from torch.quantization import quantize_dynamic

Load the tokenizer

tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')

Initialize the model structure

model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', return_dict=True)

Apply dynamic quantization to match the saved model structure

quantized_model = quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)

Now load your quantized model state_dict

quantized_model.load_state_dict(torch.load('brain.pt', map_location=torch.device('cpu')))

If you're using a GPU, move the model to GPU

quantized_model.to("cuda" if torch.cuda.is_available() else "cpu") def ask_model(question): inputs = tokenizer(question, return_tensors="pt", padding=True, truncation=True, max_length=512) inputs = inputs.to("cuda" if torch.cuda.is_available() else "cpu") with torch.no_grad(): outputs = quantized_model(**inputs) predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) return predictions # Return the raw tensor of predictions import torch

def simple_chatbot(input_text): # Classify the input text using your model predictions = ask_model(input_text) # This should now return a tensor probabilities = torch.nn.functional.softmax(predictions, dim=-1) class_index = probabilities.argmax().item() # Extract the predicted class index confidence = probabilities[0, class_index].item() # Get the confidence of the prediction

# Define your response logic based on the class index
if class_index == 1:  # Assuming class 1 is positive sentiment
    response = f"I'm glad to hear that! How can I assist you further? (Confidence: {confidence:.2f})"
elif class_index == 0:  # Assuming class 0 is negative sentiment
    response = f"I'm sorry to hear that. How can I help make things better? (Confidence: {confidence:.2f})"
else:
    response = f"Could you tell me more about it? (Confidence: {confidence:.2f})"

# Return both the input and the response including confidence
return f"User said: \"{input_text}\"\nChatbot response: {response}\n"

Example usage

print(simple_chatbot("I love this service!")) print(simple_chatbot("This is terrible.")) print(simple_chatbot("Can you help me with my account?")) print(simple_chatbot("Your app is amazing, saved me so much time!")) print(simple_chatbot("I'm not happy with the service.")) print(simple_chatbot("How does the subscription model work?"))