XLMRoBERTa_Multilingual_Sentiment_Analysis

Name: XLMRoBERTa_Multilingual_Sentiment_Analysis
Author: AventIQ-AI

—

AventIQ-AI

Other

OTHER

New

3 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

Unknown

Mobile

Laptop

Server

Quick Summary

AI model with specialized capabilities.

Code Examples

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagebash

pip install transformers torch

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Usagepythontransformers

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model and tokenizer
model_path = "your-username/xlm-roberta-sentiment-amazon-reviews"
model = AutoModelForSequenceClassification.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.eval()

# Prediction function
def predict_sentiment(texts):
    inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=1)
        preds = torch.argmax(probs, dim=1)
    
    label_map = {0: "Negative", 1: "Positive"}
    results = []
    for text, pred, prob in zip(texts, preds, probs):
        results.append({
            "text": text,
            "prediction": label_map[pred.item()],
            "confidence": round(prob[pred].item(), 4)
        })
    return results

# Example
examples = ["This product is amazing!", "Worst purchase ever."]
print(predict_sentiment(examples))

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Training Configurationtext

.
├── model/                # Fine-tuned model and config files
├── tokenizer/            # Tokenizer files
├── inference.py          # Inference and testing script
├── README.md             # Model documentation

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Try Free API

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Deploy Now

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.