i have  an error and no body can solve it… is there any body to help?
it is the erro
"    evaluate_parameters_dict[“precision”] = precision + evaluate_parameters_dict[“precision”]
ValueError: operands could not be broadcast together with shapes (5,) (14,)
"
in this code:
import torch
from sklearn.metrics import precision_recall_fscore_support
import numpy as np
from torch_chatbot.config import DEVICE
from torch_chatbot.utils import Dataset, binary_accuracy
from torch_chatbot.models import LSTM_Model
from torch import nn
import time
from torch_chatbot.make_model import MakeModel
from torch_chatbot.config import LOG_PATH, NEG_CSV, MODEL_PATH, GLOVE_MODEL_PATH, \
    EMBEDDING_SIZE, HIDDEN_SIZE, DROPOUT, N_LAYERS, N_EPOCHS, TEST_DATA, LSTM_UNITS, MODEL_NAME

log_file = open(LOG_PATH, 'w')

dataset = Dataset(NEG_CSV, GLOVE_MODEL_PATH, TEST_DATA)
dataset.load_data()

make_model = MakeModel(dataset)
# qa_similar_model, model_embedding = make_model.modeler()
model = LSTM_Model(vocab_size=len(dataset.vocab), embedding_dim=EMBEDDING_SIZE, pad_idx=dataset.PAD_IDX,
                   lstm_units=LSTM_UNITS, lstm_layers=N_LAYERS, dropout=DROPOUT, model=MODEL_NAME)
model.embeddings.weight.data.copy_(dataset.pretrain_embeddings)
model.embeddings.weight.data[dataset.PAD_IDX] = torch.zeros(EMBEDDING_SIZE)
# model.embedding.weight.requires_grad = True
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
model = model.to(DEVICE)
criterion = criterion.to(DEVICE)


def count_parameters(input_model):
    """
    method for calculate number of model's parameter
    :param input_model: model
    :return: number of parameters
    """
    return sum(p.numel() for p in input_model.parameters() if p.requires_grad)


def epoch_time(s_time, e_time):
    """
    method for calculate time
    :param s_time: start time
    :param e_time: end time
    :return: Minutes and Seconds
    """
    elapsed_time = e_time - s_time
    elapsed_mins = int(elapsed_time / 60)
    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))
    return elapsed_mins, elapsed_secs


def train(model, iterator, optimizer, criterion):
    epoch_loss = 0
    epoch_acc = 0
    model.train()
    iter_len = len(iterator)
    n_batch = 0
    for batch in iterator:
        n_batch += 1
        optimizer.zero_grad()
        qa_similary, qhidden = model(batch.question, batch.answer)
        # print("qa", qa_similary)
        loss = criterion(qa_similary, batch.label.float())
        acc = binary_accuracy(qa_similary, batch.label)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()
        epoch_acc += acc.item()
        if (n_batch % (iter_len // 3)) == 0:
            print(f'\t train on: {(n_batch / iter_len) * 100:.2f}% of samples')
            print(f'\t accuracy: {(epoch_acc / n_batch)}')
            print(f'\t loss: {(epoch_loss / n_batch)}')
            print('_______________________________________________')

            log_file.write(f'\t train on: {(n_batch / iter_len) * 100:.2f}% of samples\n')
            log_file.write(f'\t accuracy: {(epoch_acc / n_batch)}\n')
            log_file.write(f'\t loss: {(epoch_loss / n_batch)}\n')
            log_file.write('_______________________________________________\n')
    print("*************MODEL IS TRAINING!****************")
    return epoch_loss / len(iterator), epoch_acc / len(iterator)


def evaluate(model, iterator, criterion):
    evaluate_parameters_dict = {"loss": 0, "acc": 0, "precision": 0, "recall": 0, "fscore": 0}
    model.eval()
    with torch.no_grad():
        for batch in iterator:
            qa_similary, qhidden = model(batch.question, batch.answer)
            loss = criterion(qa_similary, batch.label)
            acc = binary_accuracy(qa_similary, batch.label)
            precision, recall, fscore, _ = precision_recall_fscore_support \
                (y_true=batch.label.cpu(), y_pred=np.argmax(qa_similary.cpu(), axis=1))
            evaluate_parameters_dict["loss"] += loss.item()
            evaluate_parameters_dict["acc"] += acc.item()
            evaluate_parameters_dict["precision"] = precision + evaluate_parameters_dict["precision"]
            evaluate_parameters_dict["recall"] = recall + evaluate_parameters_dict["recall"]
            evaluate_parameters_dict["fscore"] = fscore + evaluate_parameters_dict["fscore"]
        print("*************MODEL IS EVALUATING!****************")

        return evaluate_parameters_dict["loss"] / len(iterator), \
               evaluate_parameters_dict["acc"] / len(iterator), \
               evaluate_parameters_dict["precision"] / len(iterator), \
               evaluate_parameters_dict["recall"] / len(iterator), \
               evaluate_parameters_dict["fscore"] / len(iterator)


BEST_VALID_LOSS = float('inf')
for epoch in range(N_EPOCHS):
    start_time = time.time()
    train_loss, train_acc = train(model, dataset.train_iterator, optimizer, criterion)
    valid_loss, valid_acc, valid_precision, valid_recall, valid_fscore = \
        evaluate(model, dataset.val_iterator, criterion)
    end_time = time.time()

    epoch_mins, epoch_secs = epoch_time(start_time, end_time)

    if valid_loss < BEST_VALID_LOSS:
        BEST_VALID_LOSS = valid_loss
        torch.save(model,
                   MODEL_PATH + 'model_epoch{}_loss{}.pt'.format(epoch + 1, valid_loss))

    print(f'Epoch: {epoch + 1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')
    print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc * 100:.2f}%')
    print(f'\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc * 100:.2f}%')
    print(f'\t Val. Precision: {valid_precision}')
    print(f'\t Val. Recall: {valid_recall}')
    print(f'\t Val. F1_Score: {valid_fscore}')
    print('_____________________________________________________________________\n')

    log_file.write(f'Epoch: {epoch + 1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s\n')
    log_file.write(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc * 100:.2f}%\n')
    log_file.write(f'\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc * 100:.2f}%\n')
    log_file.write(f'\t Val. Precision: {valid_precision}\n')
    log_file.write(f'\t Val. Recall: {valid_recall}\n')
    log_file.write(f'\t Val. F1_Score: {valid_fscore}\n')
    log_file.write('____________________________________________________________\n')
    log_file.flush()

# lookup = EmbeddingWrapper(model_embedding, , question_tokens, vocab_size)
# result = evaluate_sample(df_qa, lookup)
# result.to_csv('some_lstm.csv')

please help:(