Deep-Adaptation-Network(DAN).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "deep-adaptation-network.ipynb",
      "provenance": [],
      "toc_visible": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "OQhDjAsmwynz"
      },
      "source": [
        "# !pip install datasets gpytorch transformers"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4U-k3C0pxCoq"
      },
      "source": [
        "# !wget https://www.dropbox.com/s/d7y0otn695k5lu4/amazon-review.zip"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z6LibJlCxIn-",
        "outputId": "cf1757e7-b03f-47fd-a800-cc605664926e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!unzip amazon-review.zip"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Archive:  amazon-review.zip\n",
            "   creating: amazon-review/\n",
            "  inflating: amazon-review/books.csv  \n",
            "  inflating: amazon-review/books-UL.csv  \n",
            "  inflating: amazon-review/dvd-UL.csv  \n",
            "  inflating: amazon-review/dvd.csv   \n",
            "  inflating: amazon-review/electronics-UL.csv  \n",
            "  inflating: amazon-review/electronics.csv  \n",
            "  inflating: amazon-review/kitchen_housewares-UL.csv  \n",
            "  inflating: amazon-review/kitchen_housewares.csv  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D31EyySUxNVX"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "trusted": true,
        "id": "WqTzwNsNwyn_"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "from transformers import BertConfig, BertTokenizer, BertTokenizerFast, BertModel\n",
        "from datasets import load_dataset\n",
        "import os\n",
        "from gpytorch.kernels.rq_kernel import RQKernel\n",
        "import pandas as pd\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from tqdm import tqdm"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "DQ4jUZMRwyoE"
      },
      "source": [
        "import torch\n",
        "from torch.autograd import Variable\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets, transforms\n",
        "from functools import partial\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import pylab\n"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "lF7i-CiwwyoJ",
        "outputId": "4bab7db6-28ef-4ea0-ba92-9cb1a66c4334",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(device)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QQXqqcuxwyoN"
      },
      "source": [
        "### Custom Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "9H721srNwyoO"
      },
      "source": [
        "class ReviewDataset(Dataset):\n",
        "    def __init__(self, data, is_unlabelled=False, model_name = \"bert-base-uncased\", max_len=512):\n",
        "        self.data = data\n",
        "        self.max_len = max_len\n",
        "        self.is_unlabelled = is_unlabelled\n",
        "        self.tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\", do_lower_case=True)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        \n",
        "        review = self.data['review_text'][index]\n",
        "        \n",
        "        encoded_input = self.tokenizer.encode_plus(\n",
        "                review,\n",
        "                add_special_tokens=True,\n",
        "                max_length= self.max_len,\n",
        "                pad_to_max_length=True,\n",
        "                return_overflowing_tokens=True,\n",
        "                truncation=True,\n",
        "                padding='max_length'\n",
        "            )\n",
        "\n",
        "        input_ids = encoded_input[\"input_ids\"]\n",
        "        attention_mask = encoded_input[\"attention_mask\"] if \"attention_mask\" in encoded_input else None\n",
        "        token_type_ids = encoded_input[\"token_type_ids\"] if \"token_type_ids\" in encoded_input else None\n",
        "\n",
        "\n",
        "        if self.is_unlabelled:\n",
        "            data_input = {\n",
        "                \"input_ids\": torch.tensor(input_ids).to(device),\n",
        "                \"attention_mask\": torch.tensor(attention_mask).to(device),\n",
        "                \"token_type_ids\": torch.tensor(token_type_ids).to(device),\n",
        "            }\n",
        "        else:\n",
        "            sentiment = self.data[\"sentiment\"][index]\n",
        "            data_input = {\n",
        "                \"input_ids\": torch.tensor(input_ids).to(device),\n",
        "                \"attention_mask\": torch.tensor(attention_mask).to(device),\n",
        "                \"token_type_ids\": torch.tensor(token_type_ids).to(device),\n",
        "                \"label\": torch.tensor(sentiment, dtype=torch.long).to(device),\n",
        "            }\n",
        "        return data_input\n",
        "\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data['review_text'])\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKyaxUtYwyoV"
      },
      "source": [
        "#### Training Config"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "QvgX7aOgwyoW"
      },
      "source": [
        "training_config = {\n",
        "    \"model_name\":\"bert-base-uncased\",\n",
        "    \"train_size\":80,\n",
        "    \"max_len\":256,\n",
        "    \"hidden_size\":768,\n",
        "    \"batch_size\":2,\n",
        "    \"lr\":1e-5,\n",
        "    \"epoch\":10,\n",
        "    \"steps_to_print\":100,\n",
        "}"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "pucvDPIfwyoa"
      },
      "source": [
        "root = \"./amazon-review/\"\n",
        "# domains = [\"books\", \"dvd\", \"electronics\", \"kitchen_housewares\"]\n",
        "source_file = \"books\"\n",
        "target_val_file = \"dvd\"\n",
        "target_train_file = \"dvd-UL\""
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "Mj7Nnoipwyoe",
        "outputId": "8b479ab4-3817-40af-c03f-59a45f5337f3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "src = load_dataset(\"csv\", data_files=root+source_file+\".csv\")['train']\n",
        "trg_train_data = load_dataset(\"csv\", data_files=root+target_train_file+\".csv\")['train']\n",
        "trg_val_data = load_dataset(\"csv\", data_files=root+target_val_file+\".csv\")['train']\n",
        "\n",
        "source_data = ReviewDataset(data=src)\n",
        "trg_train = ReviewDataset(data=trg_train_data, is_unlabelled=True)\n",
        "trg_val = ReviewDataset(data=trg_val_data) \n",
        "\n",
        "src_train, src_val = torch.utils.data.random_split(dataset=source_data, lengths=[int(len(source_data)*0.80), len(source_data)-int(len(source_data)*0.80)], generator=torch.Generator().manual_seed(42))\n",
        "# trg_train, trg_val = torch.utils.data.random_split(dataset=target_data, lengths=[int(len(target_data)*0.80), len(target_data)-int(len(target_data)*0.80)], generator=torch.Generator().manual_seed(42))\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using custom data configuration default\n",
            "Reusing dataset csv (/root/.cache/huggingface/datasets/csv/default-25926b895a54667a/0.0.0/49187751790fa4d820300fd4d0707896e5b941f1a9c644652645b866716a4ac4)\n",
            "Using custom data configuration default\n",
            "Reusing dataset csv (/root/.cache/huggingface/datasets/csv/default-90bc47a32619b67a/0.0.0/49187751790fa4d820300fd4d0707896e5b941f1a9c644652645b866716a4ac4)\n",
            "Using custom data configuration default\n",
            "Reusing dataset csv (/root/.cache/huggingface/datasets/csv/default-f6e4771184a1405b/0.0.0/49187751790fa4d820300fd4d0707896e5b941f1a9c644652645b866716a4ac4)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "F0KFU0Iwwyoi"
      },
      "source": [
        "src_trainlaoder = DataLoader(\n",
        "    dataset=src_train,\n",
        "    batch_size=training_config['batch_size'],\n",
        "    shuffle=True,\n",
        ")\n",
        "src_vallaoder = DataLoader(\n",
        "    dataset=src_val,\n",
        "    batch_size=training_config['batch_size'],\n",
        "    shuffle=False,\n",
        ")\n",
        "\n",
        "trg_trainlaoder = DataLoader(\n",
        "    dataset=trg_train,\n",
        "    batch_size=training_config['batch_size'],\n",
        "    shuffle=True,\n",
        ")\n",
        "trg_vallaoder = DataLoader(\n",
        "    dataset=trg_val,\n",
        "    batch_size=training_config['batch_size'],\n",
        "    shuffle=False,\n",
        ")"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rTVFZjYzwyom"
      },
      "source": [
        "## Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "shg5dB33wyon"
      },
      "source": [
        "class FeatureExtractor(nn.Module):\n",
        "    \n",
        "    def __init__(self, model_name):\n",
        "        super(FeatureExtractor, self).__init__()\n",
        "        self.bert = BertModel.from_pretrained(\n",
        "            pretrained_model_name_or_path=model_name,\n",
        "            output_hidden_states=True\n",
        "        )\n",
        "    \n",
        "    def forward(self, input_ids, attention_mask=None):\n",
        "        \n",
        "        top_layer, pooled_output, layers = self.bert(\n",
        "            input_ids=input_ids,\n",
        "            attention_mask=attention_mask,\n",
        "        )\n",
        "        return top_layer, pooled_output, layers\n",
        "        \n",
        "        "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "ItzjMoPkwyor"
      },
      "source": [
        "class Classifier(nn.Module):\n",
        "    \n",
        "    def __init__(self, hidden_size=768, num_classes=2):\n",
        "        super(Classifier, self).__init__()\n",
        "        \n",
        "        self.fc1 = nn.Linear(in_features=hidden_size, out_features=256)\n",
        "        self.fc2 = nn.Linear(in_features=256, out_features=128)\n",
        "        self.out = nn.Linear(in_features=128, out_features=num_classes)\n",
        "        self.relu = nn.ReLU()\n",
        "    \n",
        "    def forward(self, x):\n",
        "        fc1_out = self.relu(self.fc1(x))\n",
        "        fc2_out = self.relu(self.fc2(fc1_out))\n",
        "        logits = self.out(fc2_out)\n",
        "        return fc1_out, fc2_out, logits\n",
        "        "
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "QmcRkCU0wyou"
      },
      "source": [
        "common_net = FeatureExtractor(model_name=training_config['model_name']).to(device)\n",
        "src_net = Classifier().to(device)\n",
        "trg_net = Classifier().to(device)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "-Ur52VN9wyox"
      },
      "source": [
        "optimizer = optim.SGD([{'params': common_net.parameters()},\n",
        "                       {'params': src_net.parameters()},\n",
        "                       {'params': trg_net.parameters()}], lr= training_config['lr'])\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "uE9WQAwFwyo1"
      },
      "source": [
        "def pairwise_distance(x, y):\n",
        "\n",
        "    if not len(x.shape) == len(y.shape) == 2:\n",
        "        raise ValueError('Both inputs should be matrices.')\n",
        "\n",
        "    if x.shape[1] != y.shape[1]:\n",
        "        raise ValueError('The number of features should be the same.')\n",
        "\n",
        "    x = x.view(x.shape[0], x.shape[1], 1)\n",
        "    y = torch.transpose(y, 0, 1)\n",
        "    output = torch.sum((x - y) ** 2, 1)\n",
        "    output = torch.transpose(output, 0, 1)\n",
        "\n",
        "    return output\n",
        "\n",
        "def gaussian_kernel_matrix(x, y, sigmas):\n",
        "\n",
        "    sigmas = sigmas.view(sigmas.shape[0], 1)\n",
        "    beta = 1. / (2. * sigmas)\n",
        "    dist = pairwise_distance(x, y).contiguous()\n",
        "    dist_ = dist.view(1, -1)\n",
        "    s = torch.matmul(beta, dist_)\n",
        "\n",
        "    return torch.sum(torch.exp(-s), 0).view_as(dist)\n",
        "\n",
        "def maximum_mean_discrepancy(x, y, kernel= gaussian_kernel_matrix):\n",
        "\n",
        "    cost = torch.mean(kernel(x, x))\n",
        "    cost += torch.mean(kernel(y, y))\n",
        "    cost -= 2 * torch.mean(kernel(x, y))\n",
        "\n",
        "    return cost\n",
        "\n",
        "def mmd_loss(source_features, target_features):\n",
        "\n",
        "    sigmas = [\n",
        "        1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 5, 10, 15, 20, 25, 30, 35, 100,\n",
        "        1e3, 1e4, 1e5, 1e6\n",
        "    ]\n",
        "#     if params.use_gpu:\n",
        "#         gaussian_kernel = partial(\n",
        "#             gaussian_kernel_matrix, sigmas = Variable(torch.cuda.FloatTensor(sigmas))\n",
        "#         )\n",
        "#     else:\n",
        "    gaussian_kernel = partial(\n",
        "        gaussian_kernel_matrix, sigmas = Variable(torch.cuda.FloatTensor(sigmas))\n",
        "    )\n",
        "    loss_value = maximum_mean_discrepancy(source_features, target_features, kernel= gaussian_kernel)\n",
        "    loss_value = loss_value\n",
        "\n",
        "    return loss_value"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "fha-fpJ-wyo4"
      },
      "source": [
        "def accuracy(y, y_):\n",
        "    correct = 0\n",
        "    for i in range(y.shape[0]):\n",
        "        if y[i]==y_[i]:\n",
        "            correct += 1\n",
        "            \n",
        "    return correct/y.shape[0]"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "fyfGcjkAwyo8"
      },
      "source": [
        "def eval(common_net, src_net, dataloader):\n",
        "    acc = []\n",
        "    \n",
        "    common_net.eval()\n",
        "    src_net.eval()\n",
        "    \n",
        "    for batch in tqdm(dataloader):\n",
        "        _, features, _ = common_net(batch['input_ids'], batch['attention_mask'])\n",
        "        _, _, logits = src_net(features)\n",
        "        acc.append(accuracy(batch['label'], logits.argmax(dim=1)))\n",
        "    return sum(acc)/len(dataloader)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T4TGZZNgyzxX"
      },
      "source": [
        "# print(eval(common_net, src_net, trg_vallaoder))"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WGkdXQB6y8i1"
      },
      "source": [
        ""
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "wjsfmN26wyo_"
      },
      "source": [
        "def train(common_net, src_net, trg_net, optimizer, criterion, epoch,\n",
        "          source_dataloader, target_dataloader, train_hist):\n",
        "\n",
        "    common_net.train()\n",
        "    src_net.train()\n",
        "    trg_net.train()\n",
        "\n",
        "    start_steps = epoch * len(source_dataloader)\n",
        "    total_steps = training_config['epoch'] * len(source_dataloader)\n",
        "\n",
        "    source_iter = iter(source_dataloader)\n",
        "    target_iter = iter(target_dataloader)\n",
        "\n",
        "    start = 0\n",
        "    for batch_idx in range(min(len(source_dataloader), len(target_dataloader))):\n",
        "        # get data\n",
        "        sdata = next(source_iter)\n",
        "        tdata = next(target_iter)\n",
        "\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        _, src_features, _ = common_net(sdata['input_ids'], sdata['attention_mask'])\n",
        "        _, trg_features, _ = common_net(tdata['input_ids'], tdata['attention_mask'])\n",
        "        \n",
        "        src_fc1_out, src_fc2_out, src_logits = src_net(src_features)\n",
        "        trg_fc1_out, trg_fc2_out, trg_logits = trg_net(trg_features)\n",
        "        \n",
        "        class_loss = criterion(src_logits, sdata['label'])\n",
        "        mmd = 0.5*mmd_loss(src_features, trg_features) + 0.5*mmd_loss(src_fc1_out, trg_fc1_out) + 0.5*mmd_loss(src_fc2_out, trg_fc2_out) +  0.5*mmd_loss(src_logits, trg_logits)\n",
        "        \n",
        "        \n",
        "\n",
        "        loss = class_loss + mmd\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        step = epoch * len(target_dataloader) + batch_idx\n",
        "        start += 1\n",
        "        \n",
        "        if (start) % training_config['steps_to_print'] == 0:\n",
        "            src_acc = eval(common_net, src_net, src_vallaoder)\n",
        "            trg_acc = eval(common_net, src_net, trg_vallaoder)\n",
        "            print(f'{start}/{total_steps} | Total_loss = {loss.item():.4f} | Class_loss = {class_loss.item():.4f} | MMD_loss = {mmd.item():.2f} | SRC_acc = {src_acc:.4f} | TRG_acc = {trg_acc:.4f}')\n",
        "        train_hist['Total_loss'].append(loss.cpu().item())\n",
        "        train_hist['Class_loss'].append(class_loss.cpu().item())\n",
        "        train_hist['MMD_loss'].append(mmd.cpu().item())"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "_jgY2DLBwypC"
      },
      "source": [
        "train_hist = {}\n",
        "train_hist['Total_loss'] = []\n",
        "train_hist['Class_loss'] = []\n",
        "train_hist['MMD_loss'] = []"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "NVRYBF_2wypG",
        "outputId": "ba0b4121-96e0-4ed0-f2e0-53395256df4f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "train(\n",
        "    common_net=common_net,\n",
        "    src_net=src_net,\n",
        "    trg_net=trg_net,\n",
        "    optimizer=optimizer,\n",
        "    criterion=criterion,\n",
        "    epoch=training_config['epoch'],\n",
        "    source_dataloader=src_trainlaoder,\n",
        "    target_dataloader=trg_trainlaoder,\n",
        "    train_hist=train_hist\n",
        ")"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.37it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.35it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "100/7950 | Total_loss = 18.6403 | Class_loss = 0.7006 | MMD_loss = 17.94 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.33it/s]\n",
            "100%|██████████| 989/989 [01:36<00:00, 10.30it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "200/7950 | Total_loss = 17.6674 | Class_loss = 0.6853 | MMD_loss = 16.98 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.27it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.32it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "300/7950 | Total_loss = 19.1500 | Class_loss = 0.7580 | MMD_loss = 18.39 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.32it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.36it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "400/7950 | Total_loss = 15.9169 | Class_loss = 0.7301 | MMD_loss = 15.19 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.34it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.32it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "500/7950 | Total_loss = 15.4561 | Class_loss = 0.6551 | MMD_loss = 14.80 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.26it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.31it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "600/7950 | Total_loss = 14.5536 | Class_loss = 0.6987 | MMD_loss = 13.85 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 199/199 [00:19<00:00, 10.32it/s]\n",
            "100%|██████████| 989/989 [01:35<00:00, 10.32it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "700/7950 | Total_loss = 14.1620 | Class_loss = 0.6972 | MMD_loss = 13.46 | SRC_acc = 0.5101 | TRG_acc = 0.4990\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "rNIhNqMgwypX"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "trusted": true,
        "id": "0KtDgm9Pwypb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}