I have this code: from keras.layers import MultiHeadAttention
from PyQt5 import QtWidgets
import pickle
import sys

import numpy as np
from keras.preprocessing.sequence import pad_sequences
from keras.models import load_model


# Global variables
model = None
tokenizer = None
history = ""
dark_mode = False


class Chatbot(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.layout = QtWidgets.QVBoxLayout()

        # Model selection buttons
        self.model_label = QtWidgets.QLabel("Select Model:")
        self.model_button = QtWidgets.QPushButton("Browse...")
        self.model_button.clicked.connect(self.select_model)

        # Tokenizer selection buttons
        self.tokenizer_label = QtWidgets.QLabel("Select Tokenizer:")
        self.tokenizer_button = QtWidgets.QPushButton("Browse...")
        self.tokenizer_button.clicked.connect(self.select_tokenizer)

        self.input_box = QtWidgets.QLineEdit()
        self.input_box.returnPressed.connect(self.on_text_input)

        self.mode_switch = QtWidgets.QCheckBox("Chat mode")
        self.mode_switch.stateChanged.connect(self.on_mode_switch)

        self.dark_mode_button = QtWidgets.QPushButton("Dark Mode")
        self.dark_mode_button.clicked.connect(self.toggle_dark_mode)

        self.send_button = QtWidgets.QPushButton("Send")
        self.send_button.clicked.connect(self.on_send_button)

        self.load_model_button = QtWidgets.QPushButton("Load Model")
        self.load_model_button.clicked.connect(self.select_model)

        self.load_tokenizer_button = QtWidgets.QPushButton("Load Tokenizer")
        self.load_tokenizer_button.clicked.connect(self.select_tokenizer)

        self.chat_box = QtWidgets.QPlainTextEdit()
        self.layout.addWidget(self.chat_box)
        self.layout.addWidget(self.input_box)
        self.layout.addWidget(self.mode_switch)
        self.layout.addWidget(self.dark_mode_button)
        self.layout.addWidget(self.send_button)
        self.layout.addWidget(self.load_model_button)
        self.layout.addWidget(self.load_tokenizer_button)

        self.setLayout(self.layout)
        self.setWindowTitle("Chatbot")
        self.show()

    def on_text_input(self):
        global model, tokenizer
        user_text = self.input_box.text()
        self.input_box.clear()

        if self.mode_switch.isChecked():
            # Chat mode
            self.generate_chat_response(user_text)
        else:
            # Text completion mode
            self.complete_text(user_text)

    def on_mode_switch(self):
        if self.mode_switch.isChecked():
            self.chat_box.appendPlainText("Chat mode activated.")
        else:
            self.chat_box.appendPlainText("Text completion mode activated.")

    def toggle_dark_mode(self):
        global dark_mode
        dark_mode = not dark_mode

        if dark_mode:
            self.setStyleSheet("background-color: #222222; color: #fff;")
            self.send_button.setStyleSheet("background-color: #444444; color: #fff;")
        else:
            self.setStyleSheet("background-color: #fff; color: #000;")
            self.send_button.setStyleSheet("background-color: #eee; color: #000;")

    def on_send_button(self):
        global model, tokenizer
        user_text = self.input_box.text()
        self.input_box.clear()
        self.chat_box.appendPlainText(f"You: {user_text}")

        if self.mode_switch.isChecked():
            # Chat mode
            self.generate_chat_response(user_text)
        else:
            # Text completion mode
            self.complete_text(user_text)
    
    def select_model(self):
        global model
        model_path = QtWidgets.QFileDialog.getOpenFileName(self, "Select Model File")[0]
        if model_path:
            model = load_model(model_path)

    def select_tokenizer(self):
        global tokenizer
        tokenizer_path = QtWidgets.QFileDialog.getOpenFileName(self, "Select Tokenizer File")[0]
        if tokenizer_path:
            tokenizer = pickle.load(open(tokenizer_path, "rb"))

    def generate_chat_response(self, user_text):
       global model, tokenizer, history
       history += f" {user_text}"

   # Preprocess user input and history
       input_sequence = self.preprocess_text(history)

   # Generate response using the model
       predicted_token_ids = self.predict(input_sequence)
       predicted_text = self.decode_tokens(predicted_token_ids)

       history += f" {predicted_text}"

   # Display response
       self.chat_box.appendPlainText(f"Chatbot: {predicted_text}")

    def complete_text(self, user_text):
        global model, tokenizer
        if not model:
          raise RuntimeError("Model not loaded.")
        # Preprocess user input
        input_sequence = self.preprocess_text(user_text)

        # Generate text completion using the model
        predicted_token_ids = self.predict(input_sequence)
        # Decode tokens and return completed text
        completed_text = self.decode_tokens(predicted_token_ids)
        self.chat_box.appendPlainText(f"Completion: {completed_text}")

    def preprocess_text(self, text):
        global model, tokenizer
        # Check if tokenizer is loaded
        if not tokenizer:
            raise RuntimeError("Tokenizer not loaded.")
        # Tokenize the text
        token_ids = tokenizer.texts_to_sequences([text])

        # Pad the sequence
        padded_sequence = pad_sequences(token_ids, maxlen=model.input_shape[1])

        return padded_sequence

    def predict(self, input_sequence):
       global model, tokenizer
       # Check if model is loaded
       if not model:
           raise RuntimeError("Model not loaded.")
   # Make prediction using the model
       predictions = model.predict(input_sequence)

   # Since predictions is 2-dimensional, we take the first (and only) row.
       last_prediction_probs = predictions[0]

   # Sample the next token from the predicted probabilities
       vocab_size = len(tokenizer.word_index) + 1 # The +1 accounts for the padding token.
       sampled_token_ids = np.random.choice(vocab_size, size=1, p=last_prediction_probs)

       return sampled_token_ids


    def decode_tokens(self, token_ids):
        global tokenizer
        # Check if tokenizer is loaded
        if not tokenizer:
            raise RuntimeError("Tokenizer not loaded.")
        # Decode the token IDs back to text
        predicted_text = tokenizer.index_word.get(token_ids[0], "UNKNOWN_TOKEN")

        return predicted_text

if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    chatbot = Chatbot()
    sys.exit(app.exec_()) and this is the error i get: Traceback (most recent call last):
  File "c:\Users\Dell-PC\Desktop\Projets\Model-Creator\chat-C.py", line 107, in on_send_button
    self.complete_text(user_text)
  File "c:\Users\Dell-PC\Desktop\Projets\Model-Creator\chat-C.py", line 142, in complete_text
    input_sequence = self.preprocess_text(user_text)
  File "c:\Users\Dell-PC\Desktop\Projets\Model-Creator\chat-C.py", line 156, in preprocess_text
    token_ids = tokenizer.texts_to_sequences([text])
AttributeError: 'tuple' object has no attribute 'texts_to_sequences'