create

main.py

@@ -0,0 +1,560 @@
+###### Train CIFAR10 with PyTorch. ######
+
+### IMPORT DEPENDENCIES
+
+from torch.utils.data import DataLoader
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import torch.backends.cudnn as cudnn
+import gradio as gr
+import wandb
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+import torchvision
+import torchvision.transforms as transforms
+import torchvision.models as models
+import torch.optim.lr_scheduler as lr_scheduler
+import os
+import argparse
+import torchattacks
+
+from models import *
+
+from tqdm import tqdm
+from PIL import Image
+import gradio as gr
+
+# from utils import progress_bar
+
+# CSS theme styling
+theme = gr.themes.Base(
+    font=[gr.themes.GoogleFont('Montserrat'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
+    primary_hue="emerald",
+    secondary_hue="emerald",
+    neutral_hue="zinc"
+).set(
+    body_text_color='*neutral_950',
+    body_text_color_subdued='*neutral_950',
+    block_shadow='*shadow_drop_lg',
+    button_shadow='*shadow_drop_lg',
+    block_title_text_color='*neutral_950',
+    block_title_text_weight='500',
+    slider_color='*secondary_600'
+)
+
+def normalize(img):
+    min_im = np.min(img)
+    np_img = img - min_im
+    max_im = np.max(np_img)
+    np_img /= max_im
+    return np_img
+
+def imshow(img, fig_name = "test_input.png"):
+    try:
+        img = img.clone().detach().cpu().numpy()
+    except:
+        print('img already numpy')
+
+    plt.imshow(normalize(np.transpose(img, (1, 2, 0))))
+    plt.savefig(fig_name)
+    print(f'Figure saved as {fig_name}')
+    return fig_name
+
+def class_names(class_num, class_list): # converts the raw number label to text
+    if (class_num < 0) and (class_num >= 10):
+        gr.Warning("Class List Error")
+        return
+    return class_list[class_num]
+
+
+### MAIN FUNCTION
+best_acc = 0
+def main(drop_type, epochs_sldr, train_sldr, test_sldr, learning_rate, optimizer, sigma_sldr, adv_attack, username, scheduler):
+
+    ## Input protection
+    if not drop_type:
+        gr.Warning("Please select a model from the dropdown.")
+        return
+    if not username:
+        gr.Warning("Please enter a WandB username.")
+        return
+    if(epochs_sldr % 1 != 0):
+        gr.Warning("Number of epochs must be an integer.")
+        return
+    if(train_sldr % 1 != 0):
+        gr.Warning("Training batch size must be an integer.")
+        return
+    if(test_sldr % 1 != 0):
+        gr.Warning("Testing batch size must be an integer.")
+        return
+
+    num_epochs = int(epochs_sldr)
+    global learn_batch
+    learn_batch = int(train_sldr)
+    global test_batch
+    test_batch = int(test_sldr)
+    learning_rate = float(learning_rate)
+    optimizer_choose = str(optimizer)
+    sigma = float(sigma_sldr) 
+    attack = str(adv_attack)
+    scheduler_choose = str(scheduler)
+    
+    # REPLACE ENTITY WITH USERNAME BELOW
+    wandb.init(entity=username, project="model-training")
+    
+    parser = argparse.ArgumentParser(description='PyTorch CIFAR10 Training')
+    parser.add_argument('--lr', default=0.1, type=float, help='learning rate')
+    parser.add_argument('--resume', '-r', action='store_true',
+                        help='resume from checkpoint')
+    args = parser.parse_args()
+
+    if torch.cuda.is_available():
+        device = 'cuda'
+        gr.Info("Cuda detected - running on Cuda")
+    elif torch.backends.mps.is_available():
+        device = 'mps'
+        gr.Info("MPS detected - running on Metal")
+    else:
+        device = 'cpu'
+        gr.Info("No GPU Detected - running on CPU")
+
+    start_epoch = 0  # start from epoch 0 or last checkpoint epoch
+
+    ## Data
+    try:
+        print('==> Preparing data..')
+        transform_train = transforms.Compose([
+            transforms.RandomCrop(32, padding=4),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+        ])
+
+        transform_test = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+        ])
+
+        trainset = torchvision.datasets.CIFAR10(
+            root='./data', train=True, download=True, transform=transform_train)
+        trainloader = DataLoader(
+            trainset, batch_size=learn_batch, shuffle=True, num_workers=2)
+
+        testset = torchvision.datasets.CIFAR10(
+            root='./data', train=False, download=True, transform=transform_test)
+        testloader = DataLoader(
+            testset, batch_size=test_batch, shuffle=True, num_workers=2)
+
+        classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+    except Exception as e:
+        print(f"Error: {e}")
+        gr.Warning(f"Data Loading Error: {e}")
+
+    ## Model
+    try:
+        print('==> Building model..')
+        net = models_dict.get(drop_type, None)
+
+        # Make list of models containing either classifer or fc functions
+        classifier_models = ['ConvNext_Small', 'ConvNext_Base', 'ConvNext_Large', 'DenseNet', 'EfficientNet_B0', 'MobileNetV2',
+                            'MaxVit', 'MnasNet0_5', 'SqueezeNet', 'VGG19']
+        fc_models = ['GoogLeNet', 'InceptionNetV3', 'RegNet_X_400MF', 'ResNet18', 'ShuffleNet_V2_X0_5']
+
+        # Check dropdown choice for fc or classifier function implementation
+        if net in classifier_models:
+            num_ftrs = net.classifier[-1].in_features
+            net.classifier[-1] = torch.nn.Linear(num_ftrs, len(classes))
+        elif net in fc_models:
+            num_ftrs = net.fc.in_features
+            net.fc = torch.nn.Linear(num_ftrs, len(classes))
+        
+        net = net.to(device)
+
+    except Exception as e:
+        print(f"Error: {e}")
+        gr.Warning(f"Model Building Error: {e}")
+
+    # if args.resume:
+    #     # Load checkpoint.
+    #     print('==> Resuming from checkpoint..')
+    #     assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!'
+    #     checkpoint = torch.load('./checkpoint/ckpt.pth')
+    #     net.load_state_dict(checkpoint['net'])
+    #     best_acc = checkpoint['acc']
+    #     start_epoch = checkpoint['epoch']
+
+    SGDopt = optim.SGD(net.parameters(), lr=learning_rate,momentum=0.9, weight_decay=5e-4)
+    Adamopt = optim.Adam(net.parameters(), lr=learning_rate, weight_decay=5e-4)
+
+    criterion = nn.CrossEntropyLoss()
+
+    if optimizer_choose == "SGD":
+        optimizer = SGDopt
+    elif optimizer_choose == "Adam":
+        optimizer = Adamopt
+    print (f'optimizer: {optimizer}')
+
+    #scheduler = lr_scheduler.LinearLR(optimizer, start_factor=learning_rate, end_factor=0.0001, total_iters=10)
+    if scheduler_choose == "CosineAnnealingLR":
+        scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)
+    elif scheduler_choose == "ReduceLROnPlateau":
+        scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', patience=5)
+    elif scheduler_choose == "StepLR":
+        scheduler = lr_scheduler.StepLR(optimizer, step_size=30)
+    print (f'scheduler: {scheduler_choose}')
+
+    img_labels = [] # initialize list for label generation
+    raw_image_list = [] # initialize list for image generation
+    img_list1 = [] # initialize list for combined image/labels
+    img_list2 = [] # initialize list for gaussian image generation
+    img_list3 = [] # initialize list for adversarial attack image generation
+
+    # The following lists are used when generating all images in an epoch instead of 10:
+    full_img_labels = []
+    full_raw_image_list = []
+    full_img_list1 = []
+
+    adv_num = 1 # initialize adversarial image number for naming purposes
+    global gaussian_num 
+    gaussian_num = 1 # initialize gaussian noise image number for naming purposes
+
+    for epoch in range(start_epoch, start_epoch+epochs_sldr):
+        if sigma == 0:
+            train(epoch, net, trainloader, device, optimizer, criterion, sigma)
+        else:
+            gaussian_fig = train(epoch, net, trainloader, device, optimizer, criterion, sigma)
+        acc, predicted = test(epoch, net, testloader, device, criterion)
+
+        if scheduler_choose == "ReduceLROnPlateau":
+            scheduler.step(metrics=acc)
+        elif not scheduler_choose == "None":
+            scheduler.step()
+        
+        if (((epoch-1) % 10 == 0) or (epoch == 0)) and (epoch != 1): # generate images every 10 epochs (and the 0th epoch)
+            dataiter = iter(testloader)
+            imgs, labels = next(dataiter)
+            normalized_imgs = (imgs-imgs.min())/(imgs.max()-imgs.min())
+            atk = torchattacks.PGD(net, eps=0.00015, alpha=0.0000000000000001, steps=7)
+            if attack == "Yes":
+                if normalized_imgs is None:
+                    print("error occured")
+                else:
+                    print(torch.std(normalized_imgs))
+                    atk.set_normalization_used(mean = torch.mean(normalized_imgs,axis=[0,2,3]), std=torch.std(normalized_imgs,axis=[0,2,3])/1.125)
+                    adv_images = atk(imgs, labels)
+                    fig_name = imshow(adv_images[0], fig_name = f'figures/adversarial_attack{adv_num}.png')
+                    attack_fig = Image.open(fig_name)
+                    for i in range(1): # generate 1 image per epoch
+                        img_list3.append(attack_fig)
+                        adv_num = adv_num + 1
+            for i in range(10): # generate 10 images per epoch
+                gradio_imgs = transforms.functional.to_pil_image(normalized_imgs[i])
+                raw_image_list.append(gradio_imgs) 
+                predicted_text = class_names(predicted[i].item(), classes)
+                actual_text = class_names(labels[i].item(), classes)
+                label_text = f'Epoch: {epoch} | Predicted: {predicted_text} | Actual: {actual_text}'
+                img_labels.append(label_text)
+            for i in range(test_batch): # generate all images per epoch
+                full_gradio_imgs = transforms.functional.to_pil_image(normalized_imgs[i])
+                full_raw_image_list.append(full_gradio_imgs)
+                full_predicted_text = class_names(predicted[i].item(), classes)
+                full_actual_text = class_names(labels[i].item(), classes)
+                full_label_text = f'Epoch: {epoch} | Predicted: {full_predicted_text} | Actual: {full_actual_text}'
+                full_img_labels.append(full_label_text)
+            for i in range(len(raw_image_list)):
+                img_tuple = (raw_image_list[i], img_labels[i])
+                img_list1.append(img_tuple)
+            for i in range(len(full_raw_image_list)):    
+                full_img_tuple = (full_raw_image_list[i], full_img_labels[i])
+                full_img_list1.append(full_img_tuple)
+            if sigma != 0:
+                    for i in range(1): # generate 1 image per epoch
+                        img_list2.append(gaussian_fig)
+                        gaussian_num = gaussian_num + 1
+    if (sigma == 0) and (attack == "No"):
+        return str(acc)+"%", img_list1, full_img_list1, None, None
+    elif (sigma != 0) and (attack == "No"):
+        return str(acc)+"%", img_list1, full_img_list1, img_list2, None
+    elif (sigma == 0) and (attack == "Yes"):
+        return str(acc)+"%", img_list1, full_img_list1, None, img_list3
+    else:
+        return str(acc)+"%", img_list1, full_img_list1, img_list2, img_list3
+
+
+
+### TRAINING
+def train(epoch, net, trainloader, device, optimizer, criterion, sigma, progress=gr.Progress()):
+    try:
+        print('\nEpoch: %d' % epoch)
+        net.train()
+        train_loss = 0
+        correct = 0
+        total = 0
+
+        iter_float = 50000/learn_batch
+        iterations = math.ceil(iter_float)
+        iter_prog = 0
+
+        for batch_idx, (inputs, targets) in tqdm(enumerate(trainloader)):
+            if sigma == 0:
+                inputs, targets = inputs.to(device), targets.to(device)
+                optimizer.zero_grad()
+                outputs = net(inputs)
+            else:
+                noise = np.random.normal(0, sigma, inputs.shape)
+                inputs += torch.tensor(noise)
+                inputs, targets = inputs.to(device), targets.to(device)
+                optimizer.zero_grad()
+                outputs = net(inputs)
+                n_inputs = inputs.clone().detach().cpu().numpy()
+                if(batch_idx%99 == 0):
+                        fig_name = imshow(n_inputs[0], fig_name= f'figures/gaussian_noise{gaussian_num}.png')
+                        gaussian_fig = Image.open(fig_name)
+
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            train_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += targets.size(0)
+            correct += predicted.eq(targets).sum().item()
+
+            iter_prog = iter_prog + 1 # Iterating iteration amount
+            progress(iter_prog/iterations, desc=f"Training Epoch {epoch}", total=iterations)
+            
+
+            # progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
+            #              % (train_loss/(batch_idx+1), 100.*correct/total, correct, total))
+
+    except Exception as e:
+        print(f"Error: {e}")
+        gr.Warning(f"Training Error: {e}")
+    if sigma != 0:
+        return gaussian_fig
+
+
+### TESTING
+
+def test(epoch, net, testloader, device, criterion, progress = gr.Progress()):
+    try:
+        net.eval()
+        test_loss = 0
+        correct = 0
+        total = 0
+
+        iter_float = 10000/test_batch
+        iterations = math.ceil(iter_float)
+        iter_prog = 0
+
+        with torch.no_grad():
+            for batch_idx, (inputs, targets) in tqdm(enumerate(testloader)):
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = net(inputs)
+                loss = criterion(outputs, targets)
+
+                test_loss += loss.item()
+                _, predicted = outputs.max(1)
+                total += targets.size(0)
+                correct += predicted.eq(targets).sum().item()
+
+                iter_prog = iter_prog + 1 # Iterating iteration amount
+                progress(iter_prog/iterations, desc=f"Testing Epoch {epoch}", total=iterations)
+
+            wandb.log({'epoch': epoch+1, 'loss': test_loss})
+            wandb.log({"acc": correct/total})
+
+                # progress_bar(batch_idx, len(testloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
+                #              % (test_loss/(batch_idx+1), 100.*correct/total, correct, total))
+
+        # Save checkpoint.
+        global best_acc
+        global acc
+        acc = 100.*correct/total
+        print(acc)
+        if acc > best_acc:
+            best_acc = acc
+            return best_acc, predicted
+        else:
+            return acc, predicted
+        # if acc > best_acc:
+        #     print('Saving..')
+        #     state = {
+        #         'net': net.state_dict(),
+        #         'acc': acc,
+        #         'epoch': epoch,
+        #     }
+        #     if not os.path.isdir('checkpoint'):
+        #         os.mkdir('checkpoint')
+        #     torch.save(state, './checkpoint/ckpt.pth')
+        #     best_acc = acc
+    
+    except Exception as e:
+        print(f"Error: {e}")
+        gr.Warning(f"Testing Error: {e}")
+
+
+models_dict = {
+        #"AlexNet": models.AlexNet(weights=models.AlexNet_Weights.DEFAULT),
+        #"ConvNext_Small": models.convnext_small(weights=models.ConvNeXt_Small_Weights.DEFAULT),
+        #"ConvNext_Base": models.convnext_base(weights=models.ConvNeXt_Base_Weights.DEFAULT),
+        #"ConvNext_Large": models.convnext_large(weights=models.ConvNeXt_Large_Weights.DEFAULT),
+        "DenseNet": models.densenet121(weights=models.DenseNet121_Weights.DEFAULT),
+        #"EfficientNet_B0": models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.DEFAULT),
+        #"GoogLeNet": models.googlenet(weights=models.GoogLeNet_Weights.DEFAULT),
+        # "InceptionNetV3": models.inception_v3(weights=models.Inception_V3_Weights.DEFAULT),
+        # "MaxVit": models.maxvit_t(weights=models.MaxVit_T_Weights.DEFAULT),
+        #"MnasNet0_5": models.mnasnet0_5(weights=models.MNASNet0_5_Weights.DEFAULT),
+        #"MobileNetV2": models.mobilenet_v2(weights=models.MobileNet_V2_Weights.DEFAULT),
+        "ResNet18": models.resnet18(weights=models.ResNet18_Weights.DEFAULT),
+        "ResNet50": models.resnet50(weights=models.ResNet50_Weights.DEFAULT),
+        #"RegNet_X_400MF": models.regnet_x_400mf(weights=models.RegNet_X_400MF_Weights.DEFAULT),
+        #"ShuffleNet_V2_X0_5": models.shufflenet_v2_x0_5(weights=models.ShuffleNet_V2_X0_5_Weights.DEFAULT),
+        #"SqueezeNet": models.squeezenet1_0(weights=models.SqueezeNet1_0_Weights.DEFAULT),
+        "VGG19": models.vgg19(weights=models.VGG19_Weights.DEFAULT)
+}
+
+# Store dictionary keys into list for dropdown menu choices
+names = list(models_dict.keys())
+
+# Optimizer names
+optimizers = ["SGD","Adam"]
+
+# Scheduler names
+schedulers = ["None","CosineAnnealingLR","ReduceLROnPlateau","StepLR"]
+
+### GRADIO APP INTERFACE
+
+def togglepicsettings(choice):
+    yes=gr.Gallery(visible=True)
+    no=gr.Gallery(visible=False)
+    if choice == "Yes":
+        return yes,no
+    else:
+        return no,yes
+
+def settings(choice):
+    if choice == "Advanced":
+        advanced = [
+            gr.Slider(visible=True),
+            gr.Slider(visible=True),
+            gr.Slider(visible=True),
+            gr.Dropdown(visible=True),
+            gr.Dropdown(visible=True),
+            gr.Radio(visible=True)
+        ]
+        return advanced
+    else:
+        basic = [
+            gr.Slider(visible=False),
+            gr.Slider(visible=False),
+            gr.Slider(visible=False),
+            gr.Dropdown(visible=False),
+            gr.Dropdown(visible=False),
+            gr.Radio(visible=False)
+        ]
+        return basic
+
+def attacks(choice):
+    if choice == "Yes":
+        yes = [
+            gr.Markdown(visible=True),
+            gr.Radio(visible=True),
+            gr.Radio(visible=True)
+        ]
+        return yes
+    if choice == "No":
+        no = [
+            gr.Markdown(visible=False),
+            gr.Radio(visible=False),
+            gr.Radio(visible=False)
+        ]
+        return no
+    
+def gaussian(choice):
+    if choice == "Yes":
+        yes = [
+            gr.Slider(visible=True),
+            gr.Gallery(visible=True),
+        ]
+        return yes
+    else:
+        no = [
+            gr.Slider(visible=False),
+            gr.Gallery(visible=False),
+        ]
+        return no
+def adversarial(choice):
+    if choice == "Yes":
+        yes = gr.Gallery(visible=True)
+        return yes
+    else:
+        no = gr.Gallery(visible=False)
+
+## Main app for functionality
+with gr.Blocks(css=".caption-label {display:none}") as functionApp:
+    with gr.Row():
+        gr.Markdown("# CIFAR-10 Model Training GUI")
+    with gr.Row():
+        gr.Markdown("## Parameters")
+    with gr.Row():
+        inp = gr.Dropdown(choices=names, label="Training Model", value="ResNet18", info="Choose one of 13 common models provided in the dropdown to use for training.")
+        username = gr.Textbox(label="Weights and Biases", info="Enter your username or team name from the Weights and Biases API.")
+        epochs_sldr = gr.Slider(label="Number of Epochs", minimum=1, maximum=100, step=1, value=1, info="How many times the model will see the entire dataset during trianing.")
+        with gr.Column():
+            setting_radio = gr.Radio(["Basic", "Advanced"], label="Settings", value="Basic")
+            btn = gr.Button("Run")        
+    with gr.Row():
+        train_sldr = gr.Slider(visible=False, label="Training Batch Size", minimum=1, maximum=1000, step=1, value=128, info="The number of training samples processed before the model's internal parameters are updated.")
+        test_sldr = gr.Slider(visible=False, label="Testing Batch Size", minimum=1, maximum=1000, step=1, value=100, info="The number of testing samples processed at once during the evaluation phase.")
+        learning_rate_sldr = gr.Slider(visible=False, label="Learning Rate", minimum=0.0001, maximum=0.1, step=0.0001, value=0.001, info="The learning rate of the optimization program.")
+        optimizer = gr.Dropdown(visible=False, label="Optimizer", choices=optimizers, value="SGD", info="The optimization algorithm used to minimize the loss function during training.")
+        scheduler = gr.Dropdown(visible=False, label="Scheduler", choices=schedulers, value="CosineAnnealingLR", info="The scheduler used to iteratively alter learning rate.")
+        use_attacks = gr.Radio(["Yes", "No"], visible=False, label="Use Attacking Methods?", value="No")
+        setting_radio.change(fn=settings, inputs=setting_radio, outputs=[train_sldr, test_sldr, learning_rate_sldr, optimizer, scheduler, use_attacks])
+    with gr.Row():
+        attack_method = gr.Markdown("## Attacking Methods", visible=False)
+    with gr.Row():
+        use_sigma = gr.Radio(["Yes","No"], visible=False, label="Use Gaussian Noise?", value="No")
+        sigma_sldr = gr.Slider(visible=False, label="Gaussian Noise", minimum=0, maximum=1, value=0, step=0.1, info="The sigma value of the gaussian noise eqaution. A value of 0 disables gaussian noise.")
+        adv_attack = gr.Radio(["Yes","No"], visible=False, label="Use Adversarial Attacks?", value="No")
+    with gr.Row():
+        gr.Markdown("## Training Results")
+    with gr.Row():
+        accuracy = gr.Textbox(label = "Accuracy", info="The validation accuracy of the trained model (accuracy evaluated on testing data).")
+        with gr.Column():
+            showpics = gr.Radio(["Yes","No"], visible = True, label = "Show all pictures?", value = "No")
+            pics = gr.Gallery(preview=False, selected_index=0, object_fit='contain', label="Testing Images")
+            allpics = gr.Gallery(preview=True, selected_index=0, object_fit='contain', label="Full Testing Images",visible = False)
+            showpics.change(fn=togglepicsettings, inputs=[showpics], outputs = [allpics, pics])
+    with gr.Row():
+        gaussian_pics = gr.Gallery(visible=False, preview=False, selected_index=0, object_fit='contain', label="Gaussian Noise")
+        attack_pics = gr.Gallery(visible=False, preview=False, selected_index=0, object_fit='contain', label="Adversarial Attack")
+        use_attacks.change(fn=attacks, inputs=use_attacks, outputs=[attack_method, use_sigma, adv_attack])
+        use_sigma.change(fn=gaussian, inputs=use_sigma, outputs=[sigma_sldr, gaussian_pics])
+        adv_attack.change(fn=adversarial, inputs=adv_attack, outputs=attack_pics)
+        btn.click(fn=main, inputs=[inp, epochs_sldr, train_sldr, test_sldr, learning_rate_sldr, optimizer, sigma_sldr, adv_attack, username, scheduler], outputs=[accuracy, pics, allpics, gaussian_pics, attack_pics])
+
+## Documentation app (implemented as second tab)
+
+markdown_file_path = 'documentation.md'
+with open(markdown_file_path, 'r') as file:
+    markdown_content = file.read()
+
+with gr.Blocks() as documentationApp:
+    with gr.Row():
+        gr.Markdown("# CIFAR-10 Training Interface Documentation")
+    with gr.Row():
+        gr.Markdown(markdown_content) # Can be collapesed in VSCode to hide paragraphs from view. Vscode can also wrap text.
+
+### LAUNCH APP
+
+if __name__ == '__main__':
+    mainApp = gr.TabbedInterface([functionApp, documentationApp], ["Welcome", "Documentation"], theme=theme)
+    mainApp.queue()
+    mainApp.launch()