Jupyter Notebook Rendering Duplicate Outputs (progress bars not working)

[ShriHarshaAdapalaThirumala]

Type: Bug

I am trying to print the output in for loop and every time it is printing output from previous iterations output too. The same piece of code I used is running as I expected.

Extension version: 2023.5.1001582324 VS Code version: Code 1.79.0 (Universal) (b380da4ef1ee00e224a15c1d4d9793e27c2b6302, 2023-06-07T14:29:00.206Z) OS version: Darwin arm64 22.5.0 Modes:

System Info

|Item|Value| |---|---| |CPUs|Apple M2 (8 x 24)| |GPU Status|2d_canvas: enabled
canvas_oop_rasterization: disabled_off
direct_rendering_display_compositor: disabled_off_ok
gpu_compositing: enabled
metal: disabled_off
multiple_raster_threads: enabled_on
opengl: enabled_on
rasterization: enabled
raw_draw: disabled_off_ok
video_decode: enabled
video_encode: enabled
vulkan: disabled_off
webgl: enabled
webgl2: enabled
webgpu: enabled| |Load (avg)|2, 2, 2| |Memory (System)|16.00GB (0.06GB free)| |Process Argv|--crash-reporter-id 7a68a796-b38b-4026-ad55-19aa36bbec7e| |Screen Reader|no| |VM|0%|

A/B Experiments

``` vsliv368:30146709 vsreu685:30147344 python383cf:30185419 vspor879:30202332 vspor708:30202333 vspor363:30204092 vslsvsres303:30308271 vserr242:30382549 pythontb:30283811 vsjup518:30340749 pythonptprofiler:30281270 vsdfh931cf:30280410 vshan820:30294714 vstes263:30335439 vscoreces:30445986 vscod805:30301674 binariesv615:30325510 bridge0708:30335490 bridge0723:30353136 cmake_vspar411:30581797 vsaa593:30376534 pythonvs932:30410667 cppdebug:30492333 vsclangdc:30486549 c4g48928:30535728 dsvsc012:30540252 pynewext54:30695312 azure-dev_surveyone:30548225 vsccc:30610678 2e4cg342:30602488 pyind779:30671433 f6dab269:30613381 pythonsymbol12:30671437 showlangstatbar:30737416 vsctsb:30748421 pythonms35:30701012 a2ce3375:30757347 ecj1e332:30736112 pythonfmttext:30731395 pythoncmvfstrcf:30756944 fixhidewlkth:30730051 hidesbindicator:30760978 pythongtdpathcf:30739705 i26e3531:30763805 dh2dc718:30763024 ```

[DonJayamanne]

Thank you for filling this issue and sorry you are running into this

• Please could you provide a simple sample to replicate this issue at our end with sample code and the package dependencies (so we can install them locally)
• Please ensure to provide the exact steps as well
• does this repro every time? Or only when you close vs code and reopen this or the like?

[ShriHarshaAdapalaThirumala]

`import torch import torchvision from torchmetrics.classification import MulticlassAccuracy

import matplotlib.pyplot as plt import numpy as np`

transformer = torchvision.transforms.Compose([ torchvision.transforms.Resize((64,64)), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) full_data_set = torchvision.datasets.ImageFolder('data/imagenet/', transform = transformer)

train_data_set, val_data_set,test_data_set = torch.utils.data.random_split(full_data_set, [5000,1553,1000])

train_data_loader = torch.utils.data.DataLoader(train_data_set, batch_size=64, shuffle=True) val_data_loader = torch.utils.data.DataLoader(train_data_set, batch_size=1553) test_data_loader = torch.utils.data.DataLoader(test_data_set, batch_size=1000)

if torch.backends.mps.is_available(): DEVICE = torch.device(device='mps') elif torch.cuda.is_available(): DEVICE = torch.device(device='cuda') else: DEVICE = torch.device(device='cpu')

loss_criteria = torch.nn.CrossEntropyLoss() multiclass_accuracy = MulticlassAccuracy(num_classes=len(full_data_set.classes)).to(device=DEVICE)

`def one_epoch_train(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, loss_criterion: torch.nn, optim_alog: torch.optim) -> tuple: """Function that trains the model for one epoch. Args: model (torch.nn.Module): Pytorch model we want to train. data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data. loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss. optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.

Returns:
    tuple: Output tensor carrying predicted probability of each class.
"""
batch_loss_train = []
batch_accuracy_train = []
batch_counter = 0
for inputs, labels in data_loader_train:
    inputs = inputs.to(device=DEVICE)
    labels = labels.to(device=DEVICE)

    # Enabling model training.
    model.train(True)

    #Setting gradients to zero to prevent gradient accumulation.
    optim_alog.zero_grad()

    # Forward pass.
    y_pred_prob = model(inputs)
    loss = loss_criterion(y_pred_prob, labels)

    batch_loss_train.append(loss.item())

    # Back Propagation
    loss.backward()

    # Updating weights
    optim_alog.step()

    # Calculating training accuracy.
    with torch.inference_mode():
        accuracy = multiclass_accuracy(y_pred_prob, labels)
        batch_accuracy_train.append(accuracy.item())
    batch_counter += 1

    del(inputs)
    del(labels)

return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter`

`def inference(model: torch.nn.Module, data_loader_val: torch.utils.data.DataLoader, loss_criterion: torch.nn) -> tuple: """Function that calculates test accuracy Args: model (torch.nn.Module): Pytorch model we want to make inference on. data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data. loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.

Returns:
    tuple: Tuple carrying Test loss and accuracy
"""

batch_loss_train = []
batch_accuracy_train = []
batch_counter = 0

for inputs, labels in data_loader_val:
    inputs = inputs.to(device=DEVICE)
    labels = labels.to(device=DEVICE)

    # Disabiling model training.
    model.train(False)

    with torch.inference_mode():
        # Forward Pass
        y_pred_prob = model(inputs)

        # Calculating Loss
        loss = loss_criterion(y_pred_prob, labels)
        batch_loss_train.append(loss.item())

        # Calculating Accuracy
        accuracy = multiclass_accuracy(y_pred_prob, labels)
        batch_accuracy_train.append(accuracy.item())

    batch_counter += 1

    del inputs
    del labels

return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter
    `

`def training_loop(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, data_loader_val: torch.utils.data.DataLoader, epochs:int, loss_criterion: torch.nn, optim_alog: torch.optim)-> dict: """Function that trains the model for the given number of epochs Args: model (torch.nn.Module): Pytorch model we want to train. data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data. data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data. epochs (int): Count of EPOCHS loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss. optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.

Returns:
    dict: A dictionary that carries the output metrics.
"""

loss_train = []
loss_val = []

accuracy_train = []
accuracy_val = []

# Loop that iterates over each EPOCH
for epoch in range(epochs):

    #Train the model for one EPOCH
    epoch_loss, epoch_accuracy = one_epoch_train(model, data_loader_train, loss_criterion, optim_alog)
    loss_train.append(epoch_loss)
    accuracy_train.append(epoch_accuracy)

    # Caluclating Testing results
    val_loss, val_accuracy = inference(model, data_loader_val, loss_criterion)
    loss_val.append(val_loss)
    accuracy_val.append(val_accuracy)

    if (epoch+1)%5 == 0:
        print('For Epoch {} We Train Loss:{}, Val Loss:{}, Train Accuracy:{}, Val Accuracy:{}'.format(epoch+1, epoch_loss,
                                                                                                    val_loss,
                                                                                                    epoch_accuracy,
                                                                                                    val_accuracy))
return {'training_loss':loss_train, 'val_loss':loss_val, 'training_accuracy':accuracy_train, 'val_accuracy':accuracy_val}`

`def plot_metrics(epochs: int,metrics: dict) -> None: """Plot the graphs of Training and Testing Accuracy and Loss across Epoches Args: epochs (int): Number of Epochs metrics (dict): A dictionary containing Test and Training datasets' Loss and accuracy """

plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
plt.plot(list(range(epochs)), metrics['training_loss'])
plt.plot(list(range(epochs)), metrics['val_loss'])
plt.grid()
plt.legend(['Train', 'Test'])
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Train and Validation loss across epochs')

plt.subplot(1,2,2)
plt.plot(list(range(epochs)), metrics['training_accuracy'])
plt.plot(list(range(epochs)), metrics['val_accuracy'])
plt.grid()
plt.legend(['Train', 'Test'])
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Train and Validation accuracy across epochs')

plt.show()`

`class AlexNet(torch.nn.Module): def init(self: 'AlexNet', input_size: int)-> None: """Function to initate the model layers

    Args:
        input_size (int): Input size of the image
    """
    super(AlexNet,self).__init__()

    self.max_pool = torch.nn.MaxPool2d(kernel_size=3)

    self.conv1 = torch.nn.Conv2d(in_channels=3, out_channels=96, kernel_size=11)
    conv1_size = self._get_conv_output_size(input_size, self.conv1.padding[0], self.conv1.stride[0], self.conv1.kernel_size[0])
    pool1_size = self._get_conv_output_size(conv1_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)

    self.conv2 = torch.nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, padding=2)
    conv2_size = self._get_conv_output_size(pool1_size, self.conv2.padding[0], self.conv2.stride[0], self.conv2.kernel_size[0])
    pool2_size = self._get_conv_output_size(conv2_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)

    self.conv3 = torch.nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, padding=1)
    conv3_size = self._get_conv_output_size(pool2_size, self.conv3.padding[0], self.conv3.stride[0], self.conv3.kernel_size[0])

    self.conv4 = torch.nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, padding=1)
    conv4_size = self._get_conv_output_size(conv3_size, self.conv4.padding[0], self.conv4.stride[0], self.conv4.kernel_size[0])

    self.conv5 = torch.nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1)
    conv5_size = self._get_conv_output_size(conv4_size, self.conv5.padding[0], self.conv5.stride[0], self.conv5.kernel_size[0])
    pool3_size = self._get_conv_output_size(conv5_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)

    self.linear1 = torch.nn.Linear(in_features=self.conv5.out_channels*pool3_size*pool3_size, out_features=4096)
    self.linear2 = torch.nn.Linear(in_features=4096, out_features=2048)
    self.linear3 = torch.nn.Linear(in_features=2048, out_features=1024)
    self.linear4 = torch.nn.Linear(in_features=1024, out_features=512)
    self.linear5 = torch.nn.Linear(in_features=512, out_features=256)
    self.linear6 = torch.nn.Linear(in_features=256, out_features=128)
    self.linear7 = torch.nn.Linear(in_features=128, out_features=10)

    self.dropout = torch.nn.Dropout(p=0.5)

    self.softmax = torch.nn.Softmax(dim=1)

def _get_conv_output_size(self: 'AlexNet', input_size: int, padding: int, stride: int, kernel_size: int) -> int:
    """Funtion that calculate the output convolution size

    Args:
        input_size (int): Size of the input
        padding (int): Padding size
        stride (int): Stride count
        kernel_size (int): Size of the Kernel

    Returns:
        int: Output convolution size.
    """
    return ((input_size+ (2* padding) - kernel_size)//stride)+1

def forward(self: 'AlexNet', x: torch.Tensor) -> torch.Tensor:
    """Function that performs the forward pass of the Neural Network

    Args:
        x (torch.Tensor): Input Tensor that carries that information about a batch of images

    Returns:
        torch.Tensor: Output tensor that carries the predicted probability of each class.
    """
    x = self.conv1(x)
    x = torch.nn.functional.relu(x)
    x = self.max_pool(x)

    x = self.conv2(x)
    x = torch.nn.functional.relu(x)
    x = self.max_pool(x)

    x = self.conv3(x)
    x = torch.nn.functional.relu(x)

    x = self.conv4(x)
    x = torch.nn.functional.relu(x)

    x = self.conv5(x)
    x = torch.nn.functional.relu(x)
    x = self.max_pool(x)

    x = torch.flatten(x, start_dim=1)
    x = self.linear1(x)
    x = torch.nn.functional.relu(x)
    #x = self.dropout(x)

    x = self.linear2(x)
    x = torch.nn.functional.relu(x)
    #x = self.dropout(x)

    x = self.linear3(x)
    x = torch.nn.functional.relu(x)

    x = self.linear4(x)
    x = torch.nn.functional.relu(x)

    x = self.linear5(x)
    x = torch.nn.functional.relu(x)

    x = self.linear6(x)
    x = torch.nn.functional.relu(x)

    x = self.linear7(x)
    x = torch.nn.functional.relu(x)
    x = self.softmax(x)

    return x`

torch.manual_seed(18) alx_model =AlexNet(64).to(device=DEVICE) alx_model

EPOCHS = 200 optimizer = torch.optim.Adam(alx_model.parameters(), lr=3e-5)

output_metrics = training_loop(alx_model,train_data_loader,test_data_loader,EPOCHS,loss_criteria,optimizer)

At this point my jupyter notebook is rendering output multiple times.

I am only facing issue since today morning.

[DonJayamanne]

Please could you share the notebook, it’s difficult to tell how many cells you have in your code,

also are you using a remote Jupyter server, I believe you are

thank you

[DonJayamanne]

Also what python packages do I need to install to run your sample code?

[ShriHarshaAdapalaThirumala]

Hi, I don't how to share the notebook. I don't see any upload button here.

No I am using jupyter notebook locally, that I installed in VSCODE using extension.

[DonJayamanne]

Please add the above code into a notebook and upload that into a new notebook The reason I need a notebook is I know what cells you have, right now I can’t tell if all of your code is in one cell or different cells

you can just open the notebook file as a text file and paste that here or just drag the file and upload here into an issue

see here for more info https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/attaching-files#

No I am using jupyter notebook locally

do you mean you start a Jupyter server locally and connect via vscode or Do you just run notebooks from with vscode,

please could you share your logs from the Jupyter extension Use the command ‘Jupyter: Show Output’ and copy the output and paste that here

[ShriHarshaAdapalaThirumala]

I am using notebook locally, in the sense I run notebooks with vscode. In the sense I created a virtual environment and installed ipykernel there and installed Jupyter extension in vscode and using them.

[ShriHarshaAdapalaThirumala]

{ "cells": [ { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torchvision\n", "from torchmetrics.classification import MulticlassAccuracy\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "transformer = torchvision.transforms.Compose([\n", " torchvision.transforms.Resize((64,64)),\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", " ])\n", "full_data_set = torchvision.datasets.ImageFolder('data/imagenet/', transform = transformer)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Output targets are encoded as follows: {'bicycle': 0, 'bird': 1, 'book': 2, 'car': 3, 'cat': 4, 'chair': 5, 'dog': 6, 'flower': 7, 'fruit': 8, 'tree': 9}\n" ] } ], "source": [ "print('Output targets are encoded as follows: {0}'.format(full_data_set.class_to_idx))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The size of the dataset is: 7553\n" ] } ], "source": [ "print('The size of the dataset is: {0}'.format(len(full_data_set)))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### Creating Training, Validation and Testing dataset" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "train_data_set, val_data_set,test_data_set = torch.utils.data.random_split(full_data_set, [5000,1553,1000])" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "train_data_loader = torch.utils.data.DataLoader(train_data_set, batch_size=64, shuffle=True)\n", "val_data_loader = torch.utils.data.DataLoader(train_data_set, batch_size=1553)\n", "test_data_loader = torch.utils.data.DataLoader(test_data_set, batch_size=1000)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "if torch.backends.mps.is_available():\n", " DEVICE = torch.device(device='mps')\n", "elif torch.cuda.is_available():\n", " DEVICE = torch.device(device='cuda')\n", "else:\n", " DEVICE = torch.device(device='cpu')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Learning Loop" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "loss_criteria = torch.nn.CrossEntropyLoss()\n", "multiclass_accuracy = MulticlassAccuracy(num_classes=len(full_data_set.classes)).to(device=DEVICE)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def one_epoch_train(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, \n", " loss_criterion: torch.nn, optim_alog: torch.optim) -> tuple:\n", " \"\"\"Function that trains the model for one epoch.\n", "\n", " Args:\n", " model (torch.nn.Module): Pytorch model we want to train.\n", " data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n", " loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n", " optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n", "\n", " Returns:\n", " tuple: Output tensor carrying predicted probability of each class.\n", " \"\"\"\n", " batch_loss_train = []\n", " batch_accuracy_train = []\n", " batch_counter = 0\n", " for inputs, labels in data_loader_train:\n", " inputs = inputs.to(device=DEVICE)\n", " labels = labels.to(device=DEVICE)\n", " \n", " # Enabling model training.\n", " model.train(True)\n", " \n", " #Setting gradients to zero to prevent gradient accumulation.\n", " optim_alog.zero_grad()\n", " \n", " # Forward pass.\n", " y_pred_prob = model(inputs)\n", " loss = loss_criterion(y_pred_prob, labels)\n", " \n", " batch_loss_train.append(loss.item())\n", " \n", " # Back Propagation\n", " loss.backward()\n", " \n", " # Updating weights\n", " optim_alog.step()\n", " \n", " # Calculating training accuracy.\n", " with torch.inference_mode():\n", " accuracy = multiclass_accuracy(y_pred_prob, labels)\n", " batch_accuracy_train.append(accuracy.item())\n", " batch_counter += 1\n", " \n", " del(inputs)\n", " del(labels)\n", " \n", " return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def inference(model: torch.nn.Module, data_loader_val: torch.utils.data.DataLoader, loss_criterion: torch.nn) -> tuple:\n", " \"\"\"Function that calculates test accuracy\n", "\n", " Args:\n", " model (torch.nn.Module): Pytorch model we want to make inference on.\n", " data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n", " loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n", "\n", " Returns:\n", " tuple: Tuple carrying Test loss and accuracy\n", " \"\"\"\n", " \n", " batch_loss_train = []\n", " batch_accuracy_train = []\n", " batch_counter = 0\n", " \n", " for inputs, labels in data_loader_val:\n", " inputs = inputs.to(device=DEVICE)\n", " labels = labels.to(device=DEVICE)\n", " \n", " # Disabiling model training.\n", " model.train(False)\n", " \n", " with torch.inference_mode():\n", " # Forward Pass\n", " y_pred_prob = model(inputs)\n", " \n", " # Calculating Loss\n", " loss = loss_criterion(y_pred_prob, labels)\n", " batch_loss_train.append(loss.item())\n", " \n", " # Calculating Accuracy\n", " accuracy = multiclass_accuracy(y_pred_prob, labels)\n", " batch_accuracy_train.append(accuracy.item())\n", " \n", " batch_counter += 1\n", " \n", " del inputs\n", " del labels\n", " \n", " return sum(batch_loss_train)/batch_counter, sum(batch_accuracy_train)/batch_counter\n", " " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "def training_loop(model: torch.nn.Module, data_loader_train: torch.utils.data.DataLoader, data_loader_val: torch.utils.data.DataLoader, \n", " epochs:int, loss_criterion: torch.nn, optim_alog: torch.optim)-> dict:\n", " \"\"\"Function that trains the model for the given number of epochs\n", "\n", " Args:\n", " model (torch.nn.Module): Pytorch model we want to train.\n", " data_loader_train (torch.utils.data.DataLoader): Pytorch dataloader that carries training data.\n", " data_loader_val (torch.utils.data.DataLoader): Pytorch dataloader that carries validation data.\n", " epochs (int): Count of EPOCHS\n", " loss_criterion (torch.nn): Pytorch loss criteria on which we calculate loss.\n", " optim_alog (torch.optim): Opimiztion algoritham that we use to update model weights.\n", "\n", " Returns:\n", " dict: A dictionary that carries the output metrics.\n", " \"\"\"\n", " \n", " loss_train = []\n", " loss_val = []\n", " \n", " accuracy_train = []\n", " accuracy_val = []\n", " \n", " # Loop that iterates over each EPOCH\n", " for epoch in range(epochs):\n", " \n", " #Train the model for one EPOCH\n", " epoch_loss, epoch_accuracy = one_epoch_train(model, data_loader_train, loss_criterion, optim_alog)\n", " loss_train.append(epoch_loss)\n", " accuracy_train.append(epoch_accuracy)\n", " \n", " # Caluclating Testing results\n", " val_loss, val_accuracy = inference(model, data_loader_val, loss_criterion)\n", " loss_val.append(val_loss)\n", " accuracy_val.append(val_accuracy)\n", " \n", " if (epoch+1)%5 == 0:\n", " print('For Epoch {} We Train Loss:{}, Val Loss:{}, Train Accuracy:{}, Val Accuracy:{}'.format(epoch+1, epoch_loss,\n", " val_loss,\n", " epoch_accuracy,\n", " val_accuracy))\n", " return {'training_loss':loss_train, 'val_loss':loss_val, 'training_accuracy':accuracy_train, 'val_accuracy':accuracy_val}" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def plot_metrics(epochs: int,metrics: dict) -> None:\n", " \"\"\"Plot the graphs of Training and Testing Accuracy and Loss across Epoches\n", "\n", " Args:\n", " epochs (int): Number of Epochs\n", " metrics (dict): A dictionary containing Test and Training datasets' Loss and accuracy\n", " \"\"\"\n", " \n", " plt.figure(figsize=(15,5))\n", " plt.subplot(1,2,1)\n", " plt.plot(list(range(epochs)), metrics['training_loss'])\n", " plt.plot(list(range(epochs)), metrics['val_loss'])\n", " plt.grid()\n", " plt.legend(['Train', 'Test'])\n", " plt.xlabel('Epochs')\n", " plt.ylabel('Loss')\n", " plt.title('Train and Validation loss across epochs')\n", " \n", " plt.subplot(1,2,2)\n", " plt.plot(list(range(epochs)), metrics['training_accuracy'])\n", " plt.plot(list(range(epochs)), metrics['val_accuracy'])\n", " plt.grid()\n", " plt.legend(['Train', 'Test'])\n", " plt.xlabel('Epochs')\n", " plt.ylabel('Accuracy')\n", " plt.title('Train and Validation accuracy across epochs')\n", " \n", " plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Model Building" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class AlexNet(torch.nn.Module):\n", " \n", " def init(self: 'AlexNet', input_size: int)-> None:\n", " \"\"\"Function to initate the model layers\n", "\n", " Args:\n", " input_size (int): Input size of the image\n", " \"\"\"\n", " super(AlexNet,self).init()\n", " \n", " self.max_pool = torch.nn.MaxPool2d(kernel_size=3)\n", " \n", " self.conv1 = torch.nn.Conv2d(in_channels=3, out_channels=96, kernel_size=11)\n", " conv1_size = self._get_conv_output_size(input_size, self.conv1.padding[0], self.conv1.stride[0], self.conv1.kernel_size[0])\n", " pool1_size = self._get_conv_output_size(conv1_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n", " \n", " self.conv2 = torch.nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, padding=2)\n", " conv2_size = self._get_conv_output_size(pool1_size, self.conv2.padding[0], self.conv2.stride[0], self.conv2.kernel_size[0])\n", " pool2_size = self._get_conv_output_size(conv2_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n", " \n", " self.conv3 = torch.nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, padding=1)\n", " conv3_size = self._get_conv_output_size(pool2_size, self.conv3.padding[0], self.conv3.stride[0], self.conv3.kernel_size[0])\n", " \n", " self.conv4 = torch.nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, padding=1)\n", " conv4_size = self._get_conv_output_size(conv3_size, self.conv4.padding[0], self.conv4.stride[0], self.conv4.kernel_size[0])\n", " \n", " self.conv5 = torch.nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, padding=1)\n", " conv5_size = self._get_conv_output_size(conv4_size, self.conv5.padding[0], self.conv5.stride[0], self.conv5.kernel_size[0])\n", " pool3_size = self._get_conv_output_size(conv5_size, self.max_pool.padding, self.max_pool.stride, self.max_pool.kernel_size)\n", " \n", " self.linear1 = torch.nn.Linear(in_features=self.conv5.out_channelspool3_sizepool3_size, out_features=4096)\n", " self.linear2 = torch.nn.Linear(in_features=4096, out_features=2048)\n", " self.linear3 = torch.nn.Linear(in_features=2048, out_features=1024)\n", " self.linear4 = torch.nn.Linear(in_features=1024, out_features=512)\n", " self.linear5 = torch.nn.Linear(in_features=512, out_features=256)\n", " self.linear6 = torch.nn.Linear(in_features=256, out_features=128)\n", " self.linear7 = torch.nn.Linear(in_features=128, out_features=10)\n", " \n", " self.dropout = torch.nn.Dropout(p=0.5)\n", " \n", " self.softmax = torch.nn.Softmax(dim=1)\n", " \n", " \n", " def _get_conv_output_size(self: 'AlexNet', input_size: int, padding: int, stride: int, kernel_size: int) -> int:\n", " \"\"\"Funtion that calculate the output convolution size\n", "\n", " Args:\n", " input_size (int): Size of the input\n", " padding (int): Padding size\n", " stride (int): Stride count\n", " kernel_size (int): Size of the Kernel\n", "\n", " Returns:\n", " int: Output convolution size.\n", " \"\"\"\n", " return ((input_size+ (2* padding) - kernel_size)//stride)+1\n", " \n", " \n", " def forward(self: 'AlexNet', x: torch.Tensor) -> torch.Tensor:\n", " \"\"\"Function that performs the forward pass of the Neural Network\n", "\n", " Args:\n", " x (torch.Tensor): Input Tensor that carries that information about a batch of images\n", "\n", " Returns:\n", " torch.Tensor: Output tensor that carries the predicted probability of each class.\n", " \"\"\"\n", " x = self.conv1(x)\n", " x = torch.nn.functional.relu(x)\n", " x = self.max_pool(x)\n", " \n", " x = self.conv2(x)\n", " x = torch.nn.functional.relu(x)\n", " x = self.max_pool(x)\n", " \n", " x = self.conv3(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.conv4(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.conv5(x)\n", " x = torch.nn.functional.relu(x)\n", " x = self.max_pool(x)\n", " \n", " x = torch.flatten(x, start_dim=1)\n", " x = self.linear1(x)\n", " x = torch.nn.functional.relu(x)\n", " #x = self.dropout(x)\n", " \n", " x = self.linear2(x)\n", " x = torch.nn.functional.relu(x)\n", " #x = self.dropout(x)\n", " \n", " x = self.linear3(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.linear4(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.linear5(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.linear6(x)\n", " x = torch.nn.functional.relu(x)\n", " \n", " x = self.linear7(x)\n", " x = torch.nn.functional.relu(x)\n", " x = self.softmax(x)\n", " \n", " return x" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([64, 3, 64, 64])\n" ] } ], "source": [ "for image, label in train_data_loader:\n", " print(image.shape)\n", " break" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "AlexNet(\n", " (max_pool): MaxPool2d(kernel_size=3, stride=3, padding=0, dilation=1, ceil_mode=False)\n", " (conv1): Conv2d(3, 96, kernel_size=(11, 11), stride=(1, 1))\n", " (conv2): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", " (conv3): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (conv4): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (conv5): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (linear1): Linear(in_features=1024, out_features=4096, bias=True)\n", " (linear2): Linear(in_features=4096, out_features=2048, bias=True)\n", " (linear3): Linear(in_features=2048, out_features=1024, bias=True)\n", " (linear4): Linear(in_features=1024, out_features=512, bias=True)\n", " (linear5): Linear(in_features=512, out_features=256, bias=True)\n", " (linear6): Linear(in_features=256, out_features=128, bias=True)\n", " (linear7): Linear(in_features=128, out_features=10, bias=True)\n", " (dropout): Dropout(p=0.5, inplace=False)\n", " (softmax): Softmax(dim=1)\n", ")" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "torch.manual_seed(18)\n", "alx_model =AlexNet(64).to(device=DEVICE)\n", "alx_model" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "EPOCHS = 10\n", "optimizer = torch.optim.Adam(alx_model.parameters(), lr=3e-5)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/shri/Documents/programming_environments/pytorch_env/lib/python3.11/site-packages/torchmetrics/functional/classification/stat_scores.py:416: UserWarning: MPS: no support for int64 reduction ops, casting it to int32 (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/mps/operations/ReduceOps.mm:144.)\n", " fp = confmat.sum(0) - tp\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "For Epoch 5 We Train Loss:2.2982142544999906, Val Loss:2.2944676876068115, Train Accuracy:0.09873417868644377, Val Accuracy:0.10000000149011612\n", "For Epoch 10 We Train Loss:2.257453794720807, Val Loss:2.246821880340576, Train Accuracy:0.1590176514243778, Val Accuracy:0.1588260382413864\n" ] } ], "source": [ "output_metrics = training_loop(alx_model,train_data_loader,test_data_loader,EPOCHS,loss_criteria,optimizer)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "<Figure size 1500x500 with 2 Axes>" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_metrics(epochs = EPOCHS,metrics = output_metrics)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.3" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }

[ShriHarshaAdapalaThirumala]

Output is being rendered as follows:

[DonJayamanne]

I am after the output from the Jupyter logs

• open the command palette and select ‘Jupyter: Show output’
• at the bottom you can see an output panel, it’s the place where terminal is displayed
• please copy and paste that output (it’s not part of the notebook)

[ShriHarshaAdapalaThirumala]

Sorry I just forgot about it. Here is the output I got.

Visual Studio Code (1.79.0, undefined, desktop) Jupyter Extension Version: 2023.5.1001582324. Python Extension Version: 2023.10.0. Platform: darwin (arm64). Workspace folder ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace, Home = /Users/shri 23:48:47.126 [info] Start refreshing Interpreter Kernel Picker (1686455327126) 23:48:47.130 [info] Using Pylance 23:48:47.596 [warn] Failed to get activated env vars for /usr/local/bin/python3 in 232ms 23:48:47.598 [info] Process Execution: /usr/local/bin/python3 -c "import site;print("USER_BASE_VALUE");print(site.USER_BASE);print("USER_BASE_VALUE");" 23:48:47.625 [info] Process Execution: /usr/local/bin/python3 -m pip list 23:48:47.870 [info] Starting Kernel startUsingPythonInterpreter, .jvsc74a57bd0727873e2435a742f7e85d2849e4a96dfc76b53c236b7540d1ec47fcfff026808.~/Documents/programming_environments/pytorch_env/python.~/Documents/programming_environments/pytorch_env/python.-m#ipykernel_launcher (Python Path: ~/Documents/programming_environments/pytorch_env/bin/python, Conda, 3.11.3) for '~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb' (disableUI=true) 23:48:48.587 [info] Process Execution: ~/Documents/programming_environments/pytorch_env/bin/python -c "import ipykernel; print(ipykernel.version); print("5dc3a68c-e34e-4080-9c3e-2a532b2ccb4d"); print(ipykernel.file)" 23:48:48.588 [info] Process Execution: ~/Documents/programming_environments/pytorch_env/bin/python -m ipykernel_launcher --ip=127.0.0.1 --stdin=9003 --control=9001 --hb=9000 --Session.signature_scheme="hmac-sha256" --Session.key=b"211cff0f-4889-47fc-9184-43fc44a0b7d5" --shell=9002 --transport="tcp" --iopub=9004 --f=~/Library/Jupyter/runtime/kernel-v2-41493mmdxzXV4u41K.json

cwd: ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace 23:48:48.609 [info] Process Execution: ~/Documents/programming_environments/pytorch_env/bin/python -m pip list 23:48:48.849 [info] End refreshing Interpreter Kernel Picker (1686455327126) 23:48:48.864 [info] ipykernel version & path 6.23.1, ~/Documents/programming_environments/pytorch_env/lib/python3.11/site-packages/ipykernel/init.py for ~/Documents/programming_environments/pytorch_env/bin/python 23:48:49.155 [warn] StdErr from Kernel Process 0.00s - Debugger warning: It seems that frozen modules are being used, which may 0.00s - make the debugger miss breakpoints. Please pass -Xfrozen_modules=off 0.00s - to python to disable frozen modules. 0.00s - Note: Debugging will proceed. Set PYDEVD_DISABLE_FILE_VALIDATION=1 to disable this validation. 23:48:49.222 [warn] StdErr from Kernel Process ~/Documents/programming_environments/pytorch_env/lib/python3.11/site-packages/traitlets/traitlets.py:2548: FutureWarning: Supporting extra quotes around strings is deprecated in traitlets 5.0. You can use 'hmac-sha256' instead of '"hmac-sha256"' if you require traitlets >=5. warn( 23:48:49.222 [warn] StdErr from Kernel Process ~/Documents/programming_environments/pytorch_env/lib/python3.11/site-packages/traitlets/traitlets.py:2499: FutureWarning: Supporting extra quotes around Bytes is deprecated in traitlets 5.0. Use '211cff0f-4889-47fc-9184-43fc44a0b7d5' instead of 'b"211cff0f-4889-47fc-9184-43fc44a0b7d5"'. warn( 23:48:49.415 [info] Started Kernel pytorch_env (Python 3.11.3) (pid: 41577) 23:48:49.415 [info] Started new session 1b091b5c-5686-46d7-b1b9-ab14281600bc 23:48:49.440 [info] Process Execution: ~/Documents/programming_environments/pytorch_env/bin/python ~/.vscode/extensions/ms-toolsai.jupyter-2023.5.1001582324-darwin-arm64/pythonFiles/printJupyterDataDir.py 23:48:49.456 [warn] Got a non-existent Jupyer Data Dir file://~/.local/share/jupyter 23:48:51.784 [info] Handle Execution of Cells 21 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:48:51.787 [info] Kernel acknowledged execution of cell 21 @ 1686455331786 23:48:51.790 [info] End cell 21 execution @ 1686455331789, started @ 1686455331786, elapsed time = 0.003s 23:48:51.790 [warn] Cancel all remaining cells due to cancellation or failure in execution 23:52:28.740 [info] Handle Execution of Cells 0 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:28.747 [info] Kernel acknowledged execution of cell 0 @ 1686455548744 23:52:28.961 [info] Handle Execution of Cells 1 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:29.170 [info] Handle Execution of Cells 2 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:29.366 [info] Handle Execution of Cells 3 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:29.756 [info] Handle Execution of Cells 5 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:29.948 [info] Handle Execution of Cells 6 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:30.015 [info] End cell 0 execution @ 1686455550014, started @ 1686455548744, elapsed time = 1.27s 23:52:30.018 [info] Kernel acknowledged execution of cell 1 @ 1686455550016 23:52:30.050 [info] End cell 1 execution @ 1686455550049, started @ 1686455550016, elapsed time = 0.033s 23:52:30.052 [info] Kernel acknowledged execution of cell 2 @ 1686455550051 23:52:30.054 [info] End cell 2 execution @ 1686455550053, started @ 1686455550051, elapsed time = 0.002s 23:52:30.055 [info] Kernel acknowledged execution of cell 3 @ 1686455550054 23:52:30.058 [info] End cell 3 execution @ 1686455550056, started @ 1686455550054, elapsed time = 0.002s 23:52:30.060 [info] Kernel acknowledged execution of cell 5 @ 1686455550059 23:52:30.064 [info] End cell 5 execution @ 1686455550063, started @ 1686455550059, elapsed time = 0.004s 23:52:30.066 [info] Kernel acknowledged execution of cell 6 @ 1686455550065 23:52:30.068 [info] End cell 6 execution @ 1686455550067, started @ 1686455550065, elapsed time = 0.002s 23:52:30.177 [info] Handle Execution of Cells 7 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:30.192 [info] Kernel acknowledged execution of cell 7 @ 1686455550178 23:52:30.193 [info] End cell 7 execution @ 1686455550192, started @ 1686455550178, elapsed time = 0.014s 23:52:30.644 [info] Handle Execution of Cells 9 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:30.649 [info] Kernel acknowledged execution of cell 9 @ 1686455550646 23:52:30.664 [info] End cell 9 execution @ 1686455550662, started @ 1686455550646, elapsed time = 0.016s 23:52:31.102 [info] Handle Execution of Cells 10 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:31.159 [info] Kernel acknowledged execution of cell 10 @ 1686455551104 23:52:31.162 [info] End cell 10 execution @ 1686455551161, started @ 1686455551104, elapsed time = 0.057s 23:52:31.629 [info] Handle Execution of Cells 11 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:31.635 [info] Kernel acknowledged execution of cell 11 @ 1686455551631 23:52:31.637 [info] End cell 11 execution @ 1686455551636, started @ 1686455551631, elapsed time = 0.005s 23:52:31.934 [info] Handle Execution of Cells 12 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:31.942 [info] Kernel acknowledged execution of cell 12 @ 1686455551937 23:52:31.944 [info] End cell 12 execution @ 1686455551942, started @ 1686455551937, elapsed time = 0.005s 23:52:32.237 [info] Handle Execution of Cells 13 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:32.243 [info] Kernel acknowledged execution of cell 13 @ 1686455552239 23:52:32.245 [info] End cell 13 execution @ 1686455552244, started @ 1686455552239, elapsed time = 0.005s 23:52:33.102 [info] Handle Execution of Cells 15 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:33.115 [info] Kernel acknowledged execution of cell 15 @ 1686455553104 23:52:33.117 [info] End cell 15 execution @ 1686455553116, started @ 1686455553104, elapsed time = 0.012s 23:52:33.799 [info] Handle Execution of Cells 16 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:33.804 [info] Kernel acknowledged execution of cell 16 @ 1686455553802 23:52:33.960 [info] End cell 16 execution @ 1686455553959, started @ 1686455553802, elapsed time = 0.157s 23:52:34.097 [info] Handle Execution of Cells 17 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:34.100 [info] Kernel acknowledged execution of cell 17 @ 1686455554098 23:52:34.243 [info] End cell 17 execution @ 1686455554242, started @ 1686455554098, elapsed time = 0.144s 23:52:34.546 [info] Handle Execution of Cells 18 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:34.551 [info] Kernel acknowledged execution of cell 18 @ 1686455554548 23:52:34.553 [info] End cell 18 execution @ 1686455554551, started @ 1686455554548, elapsed time = 0.003s 23:52:35.081 [info] Handle Execution of Cells 19 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:35.086 [info] Kernel acknowledged execution of cell 19 @ 1686455555083 23:52:51.979 [info] Handle Execution of Cells 20 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:52:52.738 [info] Handle Execution of Cells 21 for ~/Documents/ESDS/Summer Semester/Deep Learning/Assignment_1/workspace/sadapala_assignment1_part_5.ipynb 23:56:40.052 [info] End cell 19 execution @ 1686455800051, started @ 1686455555083, elapsed time = 244.968s 23:56:40.055 [info] Kernel acknowledged execution of cell 20 @ 1686455800054 23:56:40.197 [info] End cell 20 execution @ 1686455800196, started @ 1686455800054, elapsed time = 0.142s 23:56:40.198 [info] End cell -1 execution @ undefined, started @ undefined, elapsed time = 0s

[ShriHarshaAdapalaThirumala]

In the given situation, an occurrence arises where a warning is displayed when executing a cell. However, upon implementing the command "warnings.filterwarnings('ignore')", the issue of duplicated rendering is resolved.

[davejroberts]

Just updated to latest build - this happens on at least the first cell of a notebook. After trying various scroll options and fonts, it seems the setting to initially render output as a scrollable region doesn't have any effect - the output doesn't have a scrollable output window even though the output is longer than the text line limit.

If the initial render option isn't set, when clicking the 'view as scrollable output' hyperlink, a scrollable window appears that doesn't have the duplicate logging lines issue. However, If the initial render option is set, the output still doesn't have a scrollable output window, and the hyperlink is still generated at the bottom of the output - and when the hyperlink is clicked the output is then in a small non-scrollable window, with less lines than in the configuration setting.

Having trouble creating an exact reproduction. Not an external notebook server.

[DonJayamanne]

Thank you, I have identified the issue as being a problem in VS Code, and not the Jupyter Extension.

[amunger]

this is likely fixed in the latest insiders version https://code.visualstudio.com/insiders/

[amunger]

duplicate of https://github.com/microsoft/vscode/issues/184657