File size: 2,864 Bytes
823c424 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
import json
import os
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from transformers import AutoTokenizer, AutoModel
device = "cuda" if torch.cuda.is_available() else "cpu"
tokenizer_embeddings = AutoTokenizer.from_pretrained('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
model_embeddings = AutoModel.from_pretrained('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2').to(device)
class ModerationModel(nn.Module):
def __init__(self):
input_size = 384
hidden_size = 128
output_size = 11
super(ModerationModel, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
def mean_pooling(model_output, attention_mask):
token_embeddings = model_output[0]
input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
def getEmbeddings(sentences):
encoded_input = tokenizer_embeddings(sentences, padding=True, truncation=True, return_tensors='pt').to(device)
with torch.no_grad():
model_output = model_embeddings(**encoded_input)
sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
return sentence_embeddings.cpu()
def getEmb(text):
sentences = [text]
sentence_embeddings = getEmbeddings(sentences)
return sentence_embeddings.tolist()[0]
def predict(model, embeddings):
model.eval()
with torch.no_grad():
embeddings_tensor = torch.tensor(embeddings, dtype=torch.float)
outputs = model(embeddings_tensor.unsqueeze(0))
predicted_scores = torch.sigmoid(outputs)
predicted_scores = predicted_scores.squeeze(0).tolist()
category_names = ["harassment", "harassment-threatening", "hate", "hate-threatening", "self-harm", "self-harm-instructions", "self-harm-intent", "sexual", "sexual-minors", "violence", "violence-graphic"]
result = {category: score for category, score in zip(category_names, predicted_scores)}
detected = {category: score > 0.5 for category, score in zip(category_names, predicted_scores)}
detect_value = any(detected.values())
return {"category_scores": result, 'detect': detected, 'detected': detect_value}
print('Load model')
moderation = ModerationModel()
moderation.load_state_dict(torch.load('moderation_model.pth'))
text = "I want to kill them."
embeddings_for_prediction = getEmb(text)
prediction = predict(moderation, embeddings_for_prediction)
print(json.dumps(prediction,indent=4))
|