""" CODE TO TRY IN COLAB !pip install -q transformers datasets torch gradio console_logging numpy import gradio as gr import torch from datasets import load_dataset from console_logging.console import Console import numpy as np from transformers import AutoModelForSequenceClassification, AutoTokenizer from transformers import TrainingArguments, Trainer from sklearn.metrics import f1_score, roc_auc_score, accuracy_score from transformers import EvalPrediction import torch console = Console() dataset = load_dataset("zeroshot/twitter-financial-news-sentiment", ) model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased") tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") #labels = [label for label in dataset['train'].features.keys() if label not in ['text']] labels = ["Bearish", "Bullish", "Neutral"] def preprocess_data(examples): # take a batch of texts text = examples["text"] # encode them encoding = tokenizer(text, padding="max_length", truncation=True, max_length=128) # add labels #labels_batch = {k: examples[k] for k in examples.keys() if k in labels} labels_batch = {'Bearish': [], 'Bullish': [], 'Neutral': []} for i in range (len(examples['label'])): labels_batch["Bearish"].append(False) labels_batch["Bullish"].append(False) labels_batch["Neutral"].append(False) if examples['label'][i] == 0: labels_batch["Bearish"][i] = True elif examples['label'][i] == 1: labels_batch["Bullish"][i] = True else: labels_batch["Neutral"][i] = True # create numpy array of shape (batch_size, num_labels) labels_matrix = np.zeros((len(text), len(labels))) # fill numpy array for idx, label in enumerate(labels): labels_matrix[:, idx] = labels_batch[label] encoding["labels"] = labels_matrix.tolist() return encoding encoded_dataset = dataset.map(preprocess_data, batched=True, remove_columns=dataset['train'].column_names) encoded_dataset.set_format("torch") id2label = {idx:label for idx, label in enumerate(labels)} label2id = {label:idx for idx, label in enumerate(labels)} model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", problem_type="multi_label_classification", num_labels=len(labels), id2label=id2label, label2id=label2id) batch_size = 8 metric_name = "f1" args = TrainingArguments( f"bert-finetuned-sem_eval-english", evaluation_strategy = "epoch", save_strategy = "epoch", learning_rate=2e-5, per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, num_train_epochs=5, weight_decay=0.01, load_best_model_at_end=True, metric_for_best_model=metric_name, #push_to_hub=True, ) # source: https://jesusleal.io/2021/04/21/Longformer-multilabel-classification/ def multi_label_metrics(predictions, labels, threshold=0.5): # first, apply sigmoid on predictions which are of shape (batch_size, num_labels) sigmoid = torch.nn.Sigmoid() probs = sigmoid(torch.Tensor(predictions)) # next, use threshold to turn them into integer predictions y_pred = np.zeros(probs.shape) y_pred[np.where(probs >= threshold)] = 1 # finally, compute metrics y_true = labels f1_micro_average = f1_score(y_true=y_true, y_pred=y_pred, average='micro') roc_auc = roc_auc_score(y_true, y_pred, average = 'micro') accuracy = accuracy_score(y_true, y_pred) # return as dictionary metrics = {'f1': f1_micro_average, 'roc_auc': roc_auc, 'accuracy': accuracy} return metrics def compute_metrics(p: EvalPrediction): preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions result = multi_label_metrics( predictions=preds, labels=p.label_ids) return result trainer = Trainer( model, args, train_dataset=encoded_dataset["train"], eval_dataset=encoded_dataset["validation"], tokenizer=tokenizer, compute_metrics=compute_metrics ) trainer.train() trainer.evaluate() """ # Version to gradio and HuggingFace, doesn't works like the colab version, this version use the exported model, possible without the fine tuning import torch from datasets import load_dataset from console_logging.console import Console import numpy as np from transformers import AutoModelForSequenceClassification, AutoTokenizer from transformers import TrainingArguments, Trainer from sklearn.metrics import f1_score, roc_auc_score, accuracy_score from transformers import EvalPrediction import torch import gradio as gr console = Console() dataset = load_dataset("zeroshot/twitter-financial-news-sentiment", ) model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased") tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") #labels = [label for label in dataset['train'].features.keys() if label not in ['text']] labels = ["Bearish", "Bullish", "Neutral"] def preprocess_data(examples): # take a batch of texts text = examples["text"] # encode them encoding = tokenizer(text, padding="max_length", truncation=True, max_length=128) # add labels #labels_batch = {k: examples[k] for k in examples.keys() if k in labels} labels_batch = {'Bearish': [], 'Bullish': [], 'Neutral': []} for i in range (len(examples['label'])): labels_batch["Bearish"].append(False) labels_batch["Bullish"].append(False) labels_batch["Neutral"].append(False) if examples['label'][i] == 0: labels_batch["Bearish"][i] = True elif examples['label'][i] == 1: labels_batch["Bullish"][i] = True else: labels_batch["Neutral"][i] = True # create numpy array of shape (batch_size, num_labels) labels_matrix = np.zeros((len(text), len(labels))) # fill numpy array for idx, label in enumerate(labels): labels_matrix[:, idx] = labels_batch[label] encoding["labels"] = labels_matrix.tolist() return encoding encoded_dataset = dataset.map(preprocess_data, batched=True, remove_columns=dataset['train'].column_names) encoded_dataset.set_format("torch") id2label = {idx:label for idx, label in enumerate(labels)} label2id = {label:idx for idx, label in enumerate(labels)} model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", problem_type="multi_label_classification", num_labels=len(labels), id2label=id2label, label2id=label2id) batch_size = 8 metric_name = "f1" args = TrainingArguments( f"bert-finetuned-sem_eval-english", evaluation_strategy = "epoch", save_strategy = "epoch", learning_rate=2e-5, per_device_train_batch_size=batch_size, per_device_eval_batch_size=batch_size, num_train_epochs=5, weight_decay=0.01, load_best_model_at_end=True, metric_for_best_model=metric_name, #push_to_hub=True, ) # source: https://jesusleal.io/2021/04/21/Longformer-multilabel-classification/ def multi_label_metrics(predictions, labels, threshold=0.5): # first, apply sigmoid on predictions which are of shape (batch_size, num_labels) sigmoid = torch.nn.Sigmoid() probs = sigmoid(torch.Tensor(predictions)) # next, use threshold to turn them into integer predictions y_pred = np.zeros(probs.shape) y_pred[np.where(probs >= threshold)] = 1 # finally, compute metrics y_true = labels f1_micro_average = f1_score(y_true=y_true, y_pred=y_pred, average='micro') roc_auc = roc_auc_score(y_true, y_pred, average = 'micro') accuracy = accuracy_score(y_true, y_pred) # return as dictionary metrics = {'f1': f1_micro_average, 'roc_auc': roc_auc, 'accuracy': accuracy} return metrics def compute_metrics(p: EvalPrediction): preds = p.predictions[0] if isinstance(p.predictions, tuple) else p.predictions result = multi_label_metrics( predictions=preds, labels=p.label_ids) return result text_ = "Bitcoin to the moon" model = torch.load("./model.pt", map_location=torch.device('cpu')) trainer = Trainer( model, args, train_dataset=encoded_dataset["train"], eval_dataset=encoded_dataset["validation"], tokenizer=tokenizer, compute_metrics=compute_metrics ) tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") def predict(text): encoding = tokenizer(text, return_tensors="pt") encoding = {k: v.to(trainer.model.device) for k,v in encoding.items()} outputs = trainer.model(**encoding) logits = outputs.logits logits.shape # apply sigmoid + threshold sigmoid = torch.nn.Sigmoid() probs = sigmoid(logits.squeeze().cpu()) predictions = np.zeros(probs.shape) predictions[np.where(probs >= 0.5)] = 1 # turn predicted id's into actual label names return([id2label[idx] for idx, label in enumerate(predictions) if label == 1.0]) demo = gr.Blocks() with demo: gr.Markdown( """ # Sentiment text!!! """) inp = [gr.Textbox(label='Text or tweet text', placeholder="Insert text")] out = gr.Textbox(label='Output') text_button = gr.Button("Get the text sentiment") text_button.click(predict, inputs=inp, outputs=out) demo.launch() ############### trainer.train() trainer.evaluate()