Rewrite this code to run in a GUI with no terminal output at all: import torch
import torch.nn as nn
from transformers import BertTokenizer, GPT2Tokenizer, XLNetTokenizer
from PyQt5 import QtWidgets, QtGui
from torch.utils.data import DataLoader, Dataset
from transformers import BertTokenizer
import sys

# Step 1: Define the Language Model Configuration
def define_language_model() -> list:
    layer_type_choices = ['LSTM', 'GRU', 'Transformer']
    print("Available layer types: LSTM, GRU, Transformer")
    
    number_of_layers = int(input("Enter the number of layers: "))
    layers_configuration = []
    for i in range(number_of_layers):
        while True:
            layer_type = input(f"Enter the type of layer {i+1}: ").strip()
            if layer_type in layer_type_choices:
                layer_size = int(input(f"Enter the size for layer {i+1}: "))
                layers_configuration.append((layer_type, layer_size))
                break
            else:
                print("Invalid layer type. Please choose from LSTM, GRU, Transformer.")
    
    return layers_configuration

# Step 2: Define the Tokenizer Choice
def choose_tokenizer() -> BertTokenizer:
    tokenizer_choices = {
        'bert': BertTokenizer,
        'gpt2': GPT2Tokenizer,
        'xlnet': XLNetTokenizer
    }
    print("Available tokenizers: 'bert', 'gpt2', 'xlnet'")
    while True:
        choice = input("Choose a tokenizer: ").strip().lower()
        if choice in tokenizer_choices:
            tokenizer = tokenizer_choices[choice].from_pretrained(f"{choice}-base-cased")
            return tokenizer
        else:
            print("Invalid choice. Please select a tokenizer from 'bert', 'gpt2', 'xlnet'.")

# Example usage:
model_config = define_language_model()
tokenizer = choose_tokenizer()

print("Model configuration and tokenizer setup are now complete.")

# Example custom dataset (can be replaced with your specific data handling logic)
class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        text = self.texts[idx]
        label = self.labels[idx]
        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_length,
            return_token_type_ids=False,
            padding='max_length',
            truncation=True,
            return_attention_mask=True,
            return_tensors='pt',
        )
        return {
            'text': text,
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'labels': torch.tensor(label, dtype=torch.long)
        }

class TrainingConfigurator(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setGeometry(300, 300, 400, 300)
        self.setWindowTitle('Training Configuration')
        self.setWindowIcon(QtGui.QIcon('app_icon.png'))  # Put your app icon here

        layout = QtWidgets.QVBoxLayout()

        # Data Type Selection
        data_type_label = QtWidgets.QLabel('Select data type:', self)
        layout.addWidget(data_type_label)
        self.data_type_combo = QtWidgets.QComboBox()
        self.data_type_combo.addItems(['Text', 'Image', 'Audio'])
        layout.addWidget(self.data_type_combo)

        # Epochs Input
        epochs_label = QtWidgets.QLabel('Number of epochs:', self)
        layout.addWidget(epochs_label)
        self.epochs_spinbox = QtWidgets.QSpinBox()
        self.epochs_spinbox.setMinimum(1)
        self.epochs_spinbox.setMaximum(1000)
        layout.addWidget(self.epochs_spinbox)

        # Batch Size Input
        batch_size_label = QtWidgets.QLabel('Batch size:', self)
        layout.addWidget(batch_size_label)
        self.batch_size_spinbox = QtWidgets.QSpinBox()
        self.batch_size_spinbox.setMinimum(1)
        self.batch_size_spinbox.setMaximum(256)
        layout.addWidget(self.batch_size_spinbox)

        # Max Sequence Length Input
        max_length_label = QtWidgets.QLabel('Max sequence length:', self)
        layout.addWidget(max_length_label)
        self.max_length_spinbox = QtWidgets.QSpinBox()
        self.max_length_spinbox.setMinimum(1)
        layout.addWidget(self.max_length_spinbox)

        # Submit Button
        submit_button = QtWidgets.QPushButton('Start Training', self)
        submit_button.clicked.connect(self.start_training)
        layout.addWidget(submit_button)

        self.setLayout(layout)

    def start_training(self):
        data_type = self.data_type_combo.currentText()
        epochs = self.epochs_spinbox.value()
        batch_size = self.batch_size_spinbox.value()
        max_length = self.max_length_spinbox.value()

        # Placeholder logic for starting training
        print('Starting training with the following configuration:')
        print('Data Type:', data_type)
        print('Number of Epochs:', epochs)
        print('Batch Size:', batch_size)
        print('Max Sequence Length:', max_length)

        # This is where you would start the training process using the provided configuration.

class LanguageModelConfigurator(QtWidgets.QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        # Set window properties
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('Language Model Configuration')
        self.setWindowIcon(QtGui.QIcon('app_icon.png'))  # Put your app icon here

        vbox = QtWidgets.QVBoxLayout()

        # Model Layer Configuration
        self.layer_list_widget = QtWidgets.QListWidget()
        vbox.addWidget(self.layer_list_widget)

        hbox_layers = QtWidgets.QHBoxLayout()
        self.layer_type_combo = QtWidgets.QComboBox()
        self.layer_type_combo.addItems(['LSTM', 'GRU', 'Transformer'])
        self.layer_size_spinbox = QtWidgets.QSpinBox()
        self.layer_size_spinbox.setMinimum(1)
        self.layer_size_spinbox.setMaximum(1024)

        hbox_layers.addWidget(self.layer_type_combo)
        hbox_layers.addWidget(self.layer_size_spinbox)

        add_layer_button = QtWidgets.QPushButton('Add Layer')
        add_layer_button.clicked.connect(self.add_layer)

        hbox_layers.addWidget(add_layer_button)
        vbox.addLayout(hbox_layers)

        # Tokenizer Selection
        tokenizer_label = QtWidgets.QLabel('Choose a tokenizer:', self)
        vbox.addWidget(tokenizer_label)

        self.tokenizer_combo = QtWidgets.QComboBox()
        self.tokenizer_combo.addItems(['bert-base-cased', 'gpt2-base-cased', 'xlnet-base-cased'])
        vbox.addWidget(self.tokenizer_combo)

        # Submit Button
        submit_button = QtWidgets.QPushButton('Generate Model', self)
        submit_button.clicked.connect(self.generate_model)
        vbox.addWidget(submit_button)

        self.setLayout(vbox)

        # Apply custom style
        self.setStyleSheet("""
            QWidget {
                font-size: 14px;
            }
            QPushButton {
                background-color: #007BFF;
                border-style: none;
                padding: 6px 12px;
                color: white;
                border-radius: 4px;
            }
            QPushButton:hover {
                background-color: #0056b3;
            }
            QLabel {
                padding-bottom: 4px;
            }
        """)

    def add_layer(self):
        layer_type = self.layer_type_combo.currentText()
        layer_size = self.layer_size_spinbox.value()
        self.layer_list_widget.addItem(f'{layer_type} - Size: {layer_size}')
    
    def generate_model(self):
        layers = [(item.text().split(' - Size: ')[0], int(item.text().split(' - Size: ')[1])) for item in self.layer_list_widget.selectedItems()]
        tokenizer = self.tokenizer_combo.currentText()

        # Placeholder logic for model generation
        print('Generating model with layers:', layers)
        print('Using tokenizer:', tokenizer)

        # This is where you would pass the layer configurations and tokenizer
        # to your model creation logic.

class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('Model Training')
        self.setWindowIcon(QtGui.QIcon('app_icon.png'))  # Put your app icon here

        self.language_model_configurator = LanguageModelConfigurator()
        self.setCentralWidget(self.language_model_configurator)

        self.show()

def main():
    app = QtWidgets.QApplication(sys.argv)
    ex = MainWindow()
    sys.exit(app.exec_())

if __name__ == "__main__":
    main()