From 1e03600d7a016c5f675433829e5f67f64f9d2364 Mon Sep 17 00:00:00 2001 From: Reaper0x1 Date: Thu, 24 Oct 2024 16:59:03 +0200 Subject: [PATCH] Initial commit --- LICENSE | 201 +++ README.md | 2 + classifiers.py | 23 + custom_dataset.py | 15 + models.py | 121 ++ preprocess_data.py | 108 ++ requirements.txt | 63 + train.py | 157 ++ train_evaluate_models.ipynb | 3391 +++++++++++++++++++++++++++++++++++ utils.py | 93 + 10 files changed, 4174 insertions(+) create mode 100644 LICENSE create mode 100644 README.md create mode 100644 classifiers.py create mode 100644 custom_dataset.py create mode 100644 models.py create mode 100644 preprocess_data.py create mode 100644 requirements.txt create mode 100644 train.py create mode 100644 train_evaluate_models.ipynb create mode 100644 utils.py diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..3ec6467 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# VanillaGAN +Experiment with Vanilla GAN. diff --git a/classifiers.py b/classifiers.py new file mode 100644 index 0000000..47be3dd --- /dev/null +++ b/classifiers.py @@ -0,0 +1,23 @@ +import torch.nn as nn +from torch_geometric.nn import GCN, global_mean_pool + + +class GCNModel(nn.Module): + def __init__( + self, in_channels, hidden_channels, out_channels, num_layers=2, dropout=0.6 + ): + super().__init__() + self.gnc_model = GCN( + in_channels, hidden_channels, num_layers, dropout=dropout, jk="cat" + ) + self.fc = nn.Linear(hidden_channels, out_channels) + self.softmax = nn.Softmax(dim=1) + + def forward(self, x, edge_index, edge_weight=None, batch=None): + out = self.gnc_model(x, edge_index, edge_weight=edge_weight, batch=batch) + # print("GCN output shape: ", out.shape) + out = global_mean_pool(out, batch) # [batch_size, hidden_channels] + # print("global mean pooling output shape: ", out.shape) + out = self.softmax(self.fc(out)) + # print("softmax output shape: ", out.shape) + return out diff --git a/custom_dataset.py b/custom_dataset.py new file mode 100644 index 0000000..d902f77 --- /dev/null +++ b/custom_dataset.py @@ -0,0 +1,15 @@ +from torch.utils.data import Dataset + + +class CustomSequenceDataset(Dataset): + def __init__(self, data, labels): + self.data = data + self.labels = labels + + def __len__(self): + return len(self.data) + + def __getitem__(self, idx): + sample = self.data[idx] + label = self.labels[idx] + return sample, label diff --git a/models.py b/models.py new file mode 100644 index 0000000..21f5285 --- /dev/null +++ b/models.py @@ -0,0 +1,121 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + + +# Custom weights initialization for nn.Linear layers +def init_weights(m): + if isinstance(m, nn.Linear): + # Initialize the weights with Xavier (Glorot) uniform initialization + torch.nn.init.xavier_uniform_(m.weight) + # Set biases to a small constant value, e.g., 0.01 + if m.bias is not None: + m.bias.data.fill_(0.01) + + +class Generator(nn.Module): + def __init__( + self, + latent_dim, + seq_len, + hidden_dim, + output_dim, + embed_dim, + dropout, + conditional_info=False, + num_classes=2, + ): + super().__init__() + self.output_dim = output_dim + self.seq_len = seq_len + self.latent_dim = latent_dim + self.input_dim = self.latent_dim + self.conditional_info = conditional_info + if self.conditional_info: + if num_classes is None: + raise ValueError( + "num_classes must be provided if conditional_info is True" + ) + + self.input_dim = latent_dim + embed_dim + self.embedding = nn.Embedding(num_classes, embed_dim) + + self.model = nn.Sequential( + nn.Linear(self.input_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Linear(hidden_dim, seq_len * output_dim), + nn.ReLU(), # added ReLU here to avoid invalid logits to the gumbel softmax + ) + + def forward(self, z, labels=None, tau=0.5, hard=False): + if self.conditional_info: + if labels is None: + raise ValueError("labels must be provided if conditional_info is True") + self.embedding.to(z.device) + z = torch.cat((z, self.embedding(labels)), dim=1) + + out = self.model(z) + # reshape output to [batch_size, seq_len, output_dim] + # i.e., [batch_size, seq_len, vocab_size] + gen_data = F.gumbel_softmax( + out.view(out.shape[0], self.seq_len, self.output_dim), + tau=tau, + hard=hard, + ) + return gen_data + + +class Discriminator(nn.Module): + def __init__( + self, + input_dim, + seq_len, + hidden_dim, + embed_dim, + dropout, + conditional_info=False, + num_classes=None, + ): + super().__init__() + + self.conditional_info = conditional_info + self.input_dim = input_dim * seq_len + if self.conditional_info: + if num_classes is None: + raise ValueError( + "num_classes must be provided if conditional_info is True" + ) + self.embedding = nn.Embedding(num_classes, embed_dim) + self.input_dim = self.input_dim + embed_dim + + self.model = nn.Sequential( + nn.Linear(self.input_dim, hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(hidden_dim, 1), + nn.Sigmoid(), + ) + + def forward(self, x, labels=None): + # reshape x from [batch_size, seq_len, vocab_size] to [batch_size, seq_len * vocab_size] + x = x.reshape(x.shape[0], -1) + if self.conditional_info: + if labels is None: + raise ValueError("labels must be provided if conditional_info is True") + self.embedding.to(x.device) + # concatenate labels with input + c = self.embedding(labels) + # print(x.shape, "|", c.shape) + x = torch.cat((x, c), dim=-1) + out = self.model(x) + return out diff --git a/preprocess_data.py b/preprocess_data.py new file mode 100644 index 0000000..d58e8b3 --- /dev/null +++ b/preprocess_data.py @@ -0,0 +1,108 @@ +import os +from typing import List + +import networkx as nx +import torch +from torch_geometric.utils.convert import from_networkx + + +def read_subfolder(path: str, label): + sequences = [] + labels = [] + for filename in os.listdir(path): + if filename.endswith(".txt"): + with open(os.path.join(path, filename), "r") as f: + lines = f.readlines() + # print(lines) + + # there is only one line + line = list(map(int, lines[0].strip().split())) + sequences.append(line) + labels.append(label) + + return sequences, labels + + +def read_adfa_data(path: str): + """ + sub_dir: data folder full path (e.g. "/../.../ADFA/Training_Data_Master") + Read all files in the data folder and return a list of sequences. + """ + sequences = [] + labels = [] + + folder_name = "" + # check labels when reading attack data to be able to assign label to 1 + label = 0 # indicates benign + if "Attack_Data_Master" in path: + folder_name = "Attack_Data_Master" + label = 1 + for sub_folder in list(sorted(os.listdir(path))): + sub_folder_path = os.path.join(path, sub_folder) + if os.path.isdir(sub_folder_path): + # print("processing folder: ", sub_folder) + sub_folder_sequences, sub_folder_labels = read_subfolder( + sub_folder_path, label=label + ) + # print(f"len of sequences: {sub_folder} = {len(sub_folder_sequences)}") + + sequences.extend(sub_folder_sequences) + labels.extend(sub_folder_labels) + + # return a list of sequences, and labels for the attack data + print(f"Read {len(sequences)} sequences from {folder_name}") + return sequences, labels + + # return a list of sequences, and labels for the benign data + + sequences, labels = read_subfolder(path, label=label) + folder_name = path.split("/")[-1] + print(f"Read {len(sequences)} sequences from {folder_name}") + return sequences, labels + + +def sequence_to_graph(L: List, graph_label=None, vocab_size=None): + """ + Convert a sequence of (integers) to a graph. + Currently, we are using already encoded set of integers that represent system calls. If raw data is used, it will be necessary to encode the data first using a dictionary. + """ + # create a graph + G = nx.DiGraph() + for i in range(len(L) - 1): + edge = (L[i], L[i + 1]) + # if edge is not in the graph + if not G.has_edge(*edge): + G.add_edge(*edge, weight=1) + + # if edge is in the graph, just update the weight + else: + u, v = edge + G[u][v]["weight"] += 1 + + # add node attributes + node_attr = [] + # convert networkx graph to pyg graph data + + nodes = torch.tensor(list(G.nodes), dtype=torch.long) + node_attr = [nodes] + + # convert graph to pytorch geometric data + data = from_networkx(G) + data.x = node_attr + if graph_label is not None: + data.y = graph_label + + # validate the data + data.validate(raise_on_error=True) + + return G, data + + +def fetch_graph_data(sequences, labels, vocab_size=342): + graphs = [] + for i in range(len(sequences)): + nx_graph_G, pyg_graph_data = sequence_to_graph( + sequences[i], graph_label=labels[i], vocab_size=vocab_size + ) + graphs.append(pyg_graph_data) + return graphs diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..7caf300 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,63 @@ +aiohttp==3.9.5 +aiosignal==1.3.1 +appnope==0.1.4 +asttokens==2.4.1 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +comm==0.2.2 +contourpy==1.2.1 +cycler==0.12.1 +debugpy==1.8.1 +decorator==5.1.1 +executing==2.0.1 +filelock==3.14.0 +fonttools==4.53.0 +frozenlist==1.4.1 +fsspec==2024.5.0 +idna==3.7 +ipykernel==6.29.4 +ipython==8.25.0 +jedi==0.19.1 +Jinja2==3.1.4 +joblib==1.4.2 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +kiwisolver==1.4.5 +MarkupSafe==2.1.5 +matplotlib==3.9.0 +matplotlib-inline==0.1.7 +mpmath==1.3.0 +multidict==6.0.5 +nest-asyncio==1.6.0 +networkx==3.3 +numpy==1.26.4 +packaging==24.0 +parso==0.8.4 +pexpect==4.9.0 +pillow==10.3.0 +platformdirs==4.2.2 +prompt_toolkit==3.0.45 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +Pygments==2.18.0 +pyparsing==3.1.2 +python-dateutil==2.9.0.post0 +pyzmq==26.0.3 +requests==2.32.3 +scikit-learn==1.5.0 +scipy==1.13.1 +six==1.16.0 +stack-data==0.6.3 +sympy==1.12.1 +threadpoolctl==3.5.0 +torch==2.3.0 +torch_geometric==2.5.3 +tornado==6.4 +tqdm==4.66.4 +traitlets==5.14.3 +typing_extensions==4.12.1 +urllib3==2.2.1 +wcwidth==0.2.13 +yarl==1.9.4 diff --git a/train.py b/train.py new file mode 100644 index 0000000..fd229fc --- /dev/null +++ b/train.py @@ -0,0 +1,157 @@ +import torch +import torch.nn as nn +from sklearn.metrics import f1_score +from torch.nn import functional as F +from torch.optim import Adam +from tqdm import tqdm + + +def train_gcn_model(model, train_loader, vocab_size=342, epochs=20, device="cpu"): + optimizer = Adam(model.parameters(), lr=0.001, weight_decay=5e-4, betas=(0.5, 0.99)) + criterion = nn.CrossEntropyLoss() + + train_losses = [] + # val_losses = [] + train_f1_scores = [] + + for epoch in range(epochs): + loss_ = 0.0 + f1_score_ = 0.0 + for data in tqdm(train_loader): + # print(data) + x = F.one_hot(data.x[0], num_classes=vocab_size).float() + x = x.to(device) + edge_index = data.edge_index.to(device) + edge_weight = data.weight.float().to(device) + # y = torch.LongTensor(data.y).to(device) + y = torch.LongTensor(data.y).to(device) + batch = data.batch.to(device) + + optimizer.zero_grad() + + pred = model(x, edge_index, edge_weight=edge_weight, batch=batch) + + # print("pred", pred.shape) + loss = criterion(pred, y) + + # print("loss", loss.item()) + loss.backward() + optimizer.step() + loss_ += loss.item() + + # Convert the tensors to numpy arrays + outputs = torch.argmax(torch.clone(pred).detach().cpu(), dim=1).numpy() + targets = torch.clone(y).detach().cpu().numpy() + # Compute the F1 score + f1 = f1_score(targets, outputs, zero_division=0.0) + f1_score_ += f1 + + # Compute the average loss and F1 score + n_batches = len(train_loader) + loss_ = loss_ / n_batches + f1_score_ = f1_score_ / n_batches + train_losses.append(loss_) + train_f1_scores.append(f1_score_) + + print( + f"Epoch {epoch + 1} / {epochs}, Loss: {loss_:.4f}, F1 Score: { f1_score_:.4f}" + ) + + return train_losses, train_f1_scores + + +def train_gan_model( + generator, + discriminator, + gen_optimizer, + disc_optimizer, + train_loader, + epochs, + vocab_size, + device="cpu", + tau=0.1, + hard=False, +): + generator_losses = [] + discriminator_losses = [] + for epoch in range(1, epochs + 1): + print(f"Epoch {epoch} / {epochs}") + + gloss = 0.0 + dloss = 0.0 + for data, labels in tqdm(train_loader): + # print(labels) + + # encode data to one-hot encoding + data = F.one_hot(data.long(), vocab_size).float().to(device) + + labels = labels.long().to(device) + + # Train Discriminator + disc_optimizer.zero_grad() + # generate random noise + latent_dim = generator.latent_dim + z = torch.randn(data.shape[0], latent_dim).to(device) + # generate fake data + gen_data = generator(z, labels) + + # print("gen data shape", gen_data.shape) + + # perform discrete categorical sampling + # gen_data = F.gumbel_softmax(gen_data, tau=temperature, hard=True) + + # feed real data to discriminator + disc_real = discriminator(data, labels) + + # feed fake data to discriminator + disc_fake = discriminator(gen_data.detach(), labels) + + # compute discriminator loss + disc_loss = -torch.mean(torch.log(disc_real) + torch.log(1 - disc_fake)) + + dloss += disc_loss.item() + + # backward pass + disc_loss.backward() + + # update discriminator weights + disc_optimizer.step() + + # Train Generator + gen_optimizer.zero_grad() + z = torch.randn(data.shape[0], latent_dim).to(device) + + # generate fake data + gen_data = generator(z, labels, tau=tau, hard=hard) + + # perform discrete categorical sampling + # print("gen data shape", gen_data.shape) + # gen_data = F.gumbel_softmax(gen_data, tau=tau, hard=False, dim=-1) + + # feed fake data to discriminator + disc_fake = discriminator(gen_data, labels) + + # compute generator loss: minmax GAN's generator loss + gen_loss = torch.mean(torch.log(1 - disc_fake)) + + # for non-saturated minmax GAN's generator loss :==> generator: maximize log(D(G(z))) + # gen_loss = -torch.mean(torch.log(disc_fake)) + + gloss += gen_loss.item() + + # backward pass + gen_loss.backward() + + # update generator weights + gen_optimizer.step() + + n_batches = len(train_loader) + dloss = torch.round(torch.tensor(dloss), decimals=4) + gloss = torch.round(torch.tensor(gloss), decimals=4) + + discriminator_losses.append(dloss) + generator_losses.append(gloss) + + print(f"D Loss: {disc_loss.item():.4f}, G Loss: {gen_loss.item():.4f}") + + return generator_losses, discriminator_losses diff --git a/train_evaluate_models.ipynb b/train_evaluate_models.ipynb new file mode 100644 index 0000000..090d102 --- /dev/null +++ b/train_evaluate_models.ipynb @@ -0,0 +1,3391 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import numpy as np\n", + "from collections import Counter\n", + "from torch_geometric.loader import DataLoader\n", + "import torch.nn as nn\n", + "from torch.optim import Adam\n", + "from torch.nn.utils.rnn import pad_sequence\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "# custom modules\n", + "from models import Generator, Discriminator\n", + "from custom_dataset import CustomSequenceDataset\n", + "from preprocess_data import read_adfa_data, sequence_to_graph, fetch_graph_data\n", + "from utils import get_device, plot_loss_curve, evaluate_gcn_model\n", + "from classifiers import GCNModel\n", + "from train import train_gan_model\n", + "from train import train_gcn_model\n", + "from models import init_weights" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# for reproducibility\n", + "import random\n", + "\n", + "SEED = 42\n", + "torch.manual_seed(SEED)\n", + "np.random.seed(SEED)\n", + "random.seed(SEED)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# read, preprocess, and fetch the ADFA datasets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data_folder = \"ADFA\" # make sure \"ADFA\" folder in the parent directory of this project's folder [ie., your codes]\n", + "current_directory = Path(os.getcwd())\n", + "parent_path = current_directory.parent.absolute()\n", + "# print(current_directory.parent.absolute())\n", + "\n", + "full_data_folder_path = os.path.join(parent_path, data_folder)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 833 sequences from Training_Data_Master\n", + "Read 4372 sequences from Validation_Data_Master\n", + "Read 746 sequences from Attack_Data_Master\n" + ] + }, + { + "data": { + "text/plain": [ + "(4165, 4165, 1786, 1786)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adfa_sub_folders = [\n", + " \"Training_Data_Master\",\n", + " \"Validation_Data_Master\",\n", + " \"Attack_Data_Master\",\n", + "]\n", + "\n", + "benign_training_data_path = os.path.join(full_data_folder_path, adfa_sub_folders[0])\n", + "benign_validation_data_path = os.path.join(full_data_folder_path, adfa_sub_folders[1])\n", + "\n", + "attack_data_path = os.path.join(full_data_folder_path, adfa_sub_folders[2])\n", + "\n", + "\n", + "# read the sub folders\n", + "benign_train_sequences, benign_train_labels = read_adfa_data(benign_training_data_path)\n", + "\n", + "benign_val_sequences, benign_val_labels = read_adfa_data(benign_validation_data_path)\n", + "\n", + "attack_sequences, attack_labels = read_adfa_data(attack_data_path)\n", + "\n", + "\n", + "data = benign_train_sequences + benign_val_sequences + attack_sequences\n", + "labels = benign_train_labels + benign_val_labels + attack_labels\n", + "\n", + "# perform 70 % training and 30% testing set split\n", + "\n", + "train_data, test_data, train_labels, test_labels = train_test_split(\n", + " data, labels, test_size=0.3, random_state=42, shuffle=True, stratify=labels\n", + ")\n", + "\n", + "len(train_data), len(train_labels), len(test_data), len(test_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "746" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(attack_sequences)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({0: 3643, 1: 522})" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Data is imbalanced: 1666 samples of benign & 1051 samples of attack (malignant) will be used for training the GCN model\n", + "Counter(train_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({0: 1562, 1: 224})" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Counter(test_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a custom dataset\n", + "batch_size = 64\n", + "# convert train_data sequences and val_data sequences into graphs\n", + "\n", + "train_graph_dataset = fetch_graph_data(train_data, train_labels)\n", + "val_graph_dataset = fetch_graph_data(test_data, test_labels)\n", + "\n", + "\n", + "# Create a data loader\n", + "graph_train_loader = DataLoader(\n", + " train_graph_dataset, batch_size=batch_size, shuffle=True\n", + ")\n", + "graph_val_loader = DataLoader(val_graph_dataset, batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Data(edge_index=[2, 63], weight=[63], num_nodes=17, x=[1], y=0)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# you can see the graph data: it has edge_index, weight, num_nodes, y (label of the graph, i.e., malign or benign), and x (node features). Here, x is a list of integers representing the node features. They need to be converted to a one-hot vector of size vocab_size or vector of embedded representation.\n", + "train_graph_dataset[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 13.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1 / 35, Loss: 0.5450, F1 Score: 0.0148\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 2 / 35, Loss: 0.4404, F1 Score: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.03it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 3 / 35, Loss: 0.4313, F1 Score: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 4 / 35, Loss: 0.4190, F1 Score: 0.1648\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.27it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 5 / 35, Loss: 0.4049, F1 Score: 0.5277\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 6 / 35, Loss: 0.4005, F1 Score: 0.5737\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 7 / 35, Loss: 0.3953, F1 Score: 0.6032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.71it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 8 / 35, Loss: 0.3955, F1 Score: 0.6018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 9 / 35, Loss: 0.3929, F1 Score: 0.6133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 10 / 35, Loss: 0.3925, F1 Score: 0.6130\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 11 / 35, Loss: 0.3924, F1 Score: 0.6147\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 12 / 35, Loss: 0.3903, F1 Score: 0.6165\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 13 / 35, Loss: 0.3923, F1 Score: 0.6083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 14 / 35, Loss: 0.3935, F1 Score: 0.6034\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 15 / 35, Loss: 0.3915, F1 Score: 0.6224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.42it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 16 / 35, Loss: 0.3909, F1 Score: 0.6224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 17 / 35, Loss: 0.3868, F1 Score: 0.6434\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 18 / 35, Loss: 0.3925, F1 Score: 0.6044\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.08it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 19 / 35, Loss: 0.3896, F1 Score: 0.6274\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.70it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 20 / 35, Loss: 0.3879, F1 Score: 0.6457\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.38it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 21 / 35, Loss: 0.3893, F1 Score: 0.6227\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.85it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 22 / 35, Loss: 0.3884, F1 Score: 0.6188\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 23 / 35, Loss: 0.3875, F1 Score: 0.6431\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 24 / 35, Loss: 0.3837, F1 Score: 0.6437\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 25 / 35, Loss: 0.3848, F1 Score: 0.6553\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 26 / 35, Loss: 0.3850, F1 Score: 0.6557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 13.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 27 / 35, Loss: 0.3836, F1 Score: 0.6476\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 10.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 28 / 35, Loss: 0.3837, F1 Score: 0.6672\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 10.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 29 / 35, Loss: 0.3827, F1 Score: 0.6492\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 13.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 30 / 35, Loss: 0.3842, F1 Score: 0.6567\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 13.21it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 31 / 35, Loss: 0.3836, F1 Score: 0.6370\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 32 / 35, Loss: 0.3863, F1 Score: 0.6209\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 14.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 33 / 35, Loss: 0.3829, F1 Score: 0.6680\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 15.35it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 34 / 35, Loss: 0.3855, F1 Score: 0.6579\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 17/17 [00:01<00:00, 13.84it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 35 / 35, Loss: 0.3835, F1 Score: 0.6545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# device = get_device()\n", + "vocab_size = 342\n", + "hidden_dim = 128 # also the number of hidden nodes in the GCN. Can be set to 128, 256 or 512. If you have more GPU, you can increase it. However, you may face overfitting. Increase dropout if you face overfitting. Like dropout = 0.6, 0.7, 0.8\n", + "num_classes = 2\n", + "dropout = 0.4\n", + "output_dim = num_classes\n", + "# number of GCN layers, depending on your GPU, set it to any integer from 2 to 5.\n", + "num_layers = 3\n", + "EPOCHS_GCN = 35\n", + "\n", + "\n", + "device = torch.device(\"cpu\")\n", + "\n", + "\n", + "gcn_model = GCNModel(\n", + " in_channels=vocab_size,\n", + " hidden_channels=hidden_dim,\n", + " out_channels=num_classes,\n", + " num_layers=num_layers,\n", + " dropout=dropout,\n", + ").to(device)\n", + "\n", + "train_losses, train_f1_scores = train_gcn_model(\n", + " gcn_model,\n", + " graph_train_loader,\n", + " vocab_size=vocab_size,\n", + " epochs=EPOCHS_GCN,\n", + " device=device,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(EPOCHS_GCN, dtype=int)\n", + "plt.plot(x, train_losses, color=\"red\", label=\"GCN Training Loss\")\n", + "plt.plot(x, train_f1_scores, color=\"blue\", label=\"GCN Training F1 Score\")\n", + "plt.title(\"Training Loss and F1 Score\")\n", + "plt.xlabel(\"Epochs\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GCN performance:\n", + "Accuracy: 0.9429\n", + "Precision: 0.9130\n", + "Recall: 0.8106\n", + "F1 score: 0.8519\n", + "MCC: 0.7163\n" + ] + } + ], + "source": [ + "evaluate_gcn_model(gcn_model, graph_val_loader, vocab_size=vocab_size, device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([4165, 4094]), torch.Size([1786, 4494]))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# PREPARE DATASET FOR GAN MODEL: pad the sequences to make them of same length, then trim them to a fixed sequence length to avoid too much padding.\n", + "# convert train_data sequences and val_data sequences into graphs\n", + "SEQUENCE_LENGTH = 100\n", + "train_data_padded = pad_sequence(\n", + " [torch.tensor(sequence, dtype=torch.long) for sequence in train_data],\n", + " batch_first=True,\n", + ")\n", + "val_data_padded = pad_sequence(\n", + " [torch.tensor(sequence, dtype=torch.long) for sequence in test_data],\n", + " batch_first=True,\n", + ")\n", + "\n", + "train_data_padded.shape, val_data_padded.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "train_data_padded[:, SEQUENCE_LENGTH].shape, val_data_padded[:SEQUENCE_LENGTH].shape\n", + "\n", + "# our dataset will be of shape (n_samples, SEQUENCE_LENGTH).\n", + "train_dataset = CustomSequenceDataset(\n", + " train_data_padded[:, :SEQUENCE_LENGTH], train_labels\n", + ")\n", + "val_dataset = CustomSequenceDataset(val_data_padded[:, :SEQUENCE_LENGTH], test_labels)\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n", + "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# hyperparameters of the generator and discriminator of the GAN model\n", + "latent_dim = 100\n", + "hidden_dim = 128\n", + "vocab_size = 342 # we have 342 unique system calls in the ADFA dataset\n", + "seq_len = SEQUENCE_LENGTH # sequence length of the ADFA dataset with less than 120, will be padded. If sequence is longer than 120, it will be truncated.\n", + "output_dim = vocab_size\n", + "embed_dim = 10\n", + "dropout = 0.5\n", + "batch_size = 32\n", + "n_samples = 1000\n", + "num_classes = 2\n", + "lr = 5e-5 # 2e-6\n", + "epochs = 150\n", + "# criterion = nn.BCELoss()\n", + "criterion = nn.CrossEntropyLoss()\n", + "device = get_device()\n", + "temperature = 0.2 # 0.1\n", + "\n", + "gen = Generator(\n", + " latent_dim,\n", + " seq_len,\n", + " hidden_dim,\n", + " output_dim,\n", + " embed_dim,\n", + " dropout,\n", + " conditional_info=True,\n", + " num_classes=num_classes,\n", + ").to(device)\n", + "# gen = Gen(latent_dim, hidden_dim, seq_len, output_dim, embed_dim, dropout).to(device)\n", + "\n", + "disc = Discriminator(\n", + " vocab_size,\n", + " seq_len,\n", + " hidden_dim,\n", + " embed_dim,\n", + " dropout,\n", + " conditional_info=True,\n", + " num_classes=num_classes,\n", + ").to(device)\n", + "\n", + "\n", + "# Apply the weights initialization to your GAN model, uncomment the two lines of code below:\n", + "\n", + "# gen.apply(init_weights)\n", + "# disc.apply(init_weights)\n", + "\n", + "gen_optimizer = Adam(gen.parameters(), lr=lr, betas=(0.5, 0.999))\n", + "\n", + "disc_optimizer = Adam(disc.parameters(), lr=lr, betas=(0.5, 0.999))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "device = get_device()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# input_data = torch.randint(0, vocab_size, (n_samples, seq_len))\n", + "# input_labels = torch.randint(0, num_classes, (n_samples,))\n", + "# train_dataset = CustomSequenceDataset(input_data, input_labels)\n", + "# train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 17.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3881, G Loss: -0.6905\n", + "Epoch 2 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 17.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3966, G Loss: -0.6982\n", + "Epoch 3 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 17.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3920, G Loss: -0.6938\n", + "Epoch 4 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 16.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3851, G Loss: -0.6909\n", + "Epoch 5 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 16.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3786, G Loss: -0.6975\n", + "Epoch 6 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 17.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3862, G Loss: -0.6959\n", + "Epoch 7 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.80it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3948, G Loss: -0.6969\n", + "Epoch 8 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 16.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3930, G Loss: -0.6909\n", + "Epoch 9 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 16.16it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3790, G Loss: -0.6950\n", + "Epoch 10 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:03<00:00, 16.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3793, G Loss: -0.6889\n", + "Epoch 11 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.19it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3917, G Loss: -0.7008\n", + "Epoch 12 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.4028, G Loss: -0.6943\n", + "Epoch 13 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3859, G Loss: -0.6920\n", + "Epoch 14 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.65it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3813, G Loss: -0.6742\n", + "Epoch 15 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 16.20it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3886, G Loss: -0.6905\n", + "Epoch 16 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3937, G Loss: -0.6853\n", + "Epoch 17 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.33it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3872, G Loss: -0.6889\n", + "Epoch 18 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.50it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3827, G Loss: -0.6926\n", + "Epoch 19 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3806, G Loss: -0.6857\n", + "Epoch 20 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3865, G Loss: -0.6854\n", + "Epoch 21 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3915, G Loss: -0.6963\n", + "Epoch 22 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.07it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3851, G Loss: -0.6872\n", + "Epoch 23 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3921, G Loss: -0.6904\n", + "Epoch 24 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3857, G Loss: -0.6936\n", + "Epoch 25 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3878, G Loss: -0.6937\n", + "Epoch 26 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3928, G Loss: -0.6915\n", + "Epoch 27 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3869, G Loss: -0.6937\n", + "Epoch 28 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3930, G Loss: -0.6900\n", + "Epoch 29 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.02it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3950, G Loss: -0.6898\n", + "Epoch 30 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3910, G Loss: -0.6974\n", + "Epoch 31 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3861, G Loss: -0.7018\n", + "Epoch 32 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.39it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3871, G Loss: -0.6907\n", + "Epoch 33 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3811, G Loss: -0.6986\n", + "Epoch 34 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3876, G Loss: -0.6984\n", + "Epoch 35 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3971, G Loss: -0.7016\n", + "Epoch 36 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3907, G Loss: -0.6984\n", + "Epoch 37 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3854, G Loss: -0.6901\n", + "Epoch 38 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.69it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3917, G Loss: -0.6932\n", + "Epoch 39 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.70it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3929, G Loss: -0.6890\n", + "Epoch 40 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3838, G Loss: -0.6947\n", + "Epoch 41 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3846, G Loss: -0.7004\n", + "Epoch 42 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3854, G Loss: -0.6949\n", + "Epoch 43 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3832, G Loss: -0.7010\n", + "Epoch 44 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 15.15it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3922, G Loss: -0.6927\n", + "Epoch 45 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.27it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3928, G Loss: -0.6950\n", + "Epoch 46 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3767, G Loss: -0.6930\n", + "Epoch 47 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.21it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3910, G Loss: -0.6999\n", + "Epoch 48 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3956, G Loss: -0.6971\n", + "Epoch 49 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.01it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3760, G Loss: -0.6827\n", + "Epoch 50 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.53it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3915, G Loss: -0.6922\n", + "Epoch 51 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:08<00:00, 7.94it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3851, G Loss: -0.6912\n", + "Epoch 52 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3828, G Loss: -0.6919\n", + "Epoch 53 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.99it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3851, G Loss: -0.6938\n", + "Epoch 54 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3770, G Loss: -0.6997\n", + "Epoch 55 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3866, G Loss: -0.6991\n", + "Epoch 56 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3796, G Loss: -0.6858\n", + "Epoch 57 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3809, G Loss: -0.7107\n", + "Epoch 58 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3741, G Loss: -0.6974\n", + "Epoch 59 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3949, G Loss: -0.6967\n", + "Epoch 60 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3866, G Loss: -0.6893\n", + "Epoch 61 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3917, G Loss: -0.6919\n", + "Epoch 62 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3807, G Loss: -0.6846\n", + "Epoch 63 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3808, G Loss: -0.6956\n", + "Epoch 64 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3842, G Loss: -0.6885\n", + "Epoch 65 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3948, G Loss: -0.6959\n", + "Epoch 66 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3981, G Loss: -0.6900\n", + "Epoch 67 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3776, G Loss: -0.6922\n", + "Epoch 68 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.65it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3830, G Loss: -0.6933\n", + "Epoch 69 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3926, G Loss: -0.6985\n", + "Epoch 70 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3726, G Loss: -0.6915\n", + "Epoch 71 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3892, G Loss: -0.6962\n", + "Epoch 72 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3836, G Loss: -0.6913\n", + "Epoch 73 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.42it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3767, G Loss: -0.6861\n", + "Epoch 74 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.81it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3947, G Loss: -0.6899\n", + "Epoch 75 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3792, G Loss: -0.6888\n", + "Epoch 76 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3880, G Loss: -0.6869\n", + "Epoch 77 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.57it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3836, G Loss: -0.6960\n", + "Epoch 78 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.16it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3907, G Loss: -0.6935\n", + "Epoch 79 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.46it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3971, G Loss: -0.6990\n", + "Epoch 80 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.29it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3867, G Loss: -0.6989\n", + "Epoch 81 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3725, G Loss: -0.6966\n", + "Epoch 82 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.88it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3846, G Loss: -0.6953\n", + "Epoch 83 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3873, G Loss: -0.6934\n", + "Epoch 84 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3739, G Loss: -0.6930\n", + "Epoch 85 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.41it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3834, G Loss: -0.6918\n", + "Epoch 86 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.24it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3883, G Loss: -0.6991\n", + "Epoch 87 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3848, G Loss: -0.6867\n", + "Epoch 88 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3756, G Loss: -0.6936\n", + "Epoch 89 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.91it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3780, G Loss: -0.6895\n", + "Epoch 90 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.28it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3869, G Loss: -0.6938\n", + "Epoch 91 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.40it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3833, G Loss: -0.6918\n", + "Epoch 92 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 13.15it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3877, G Loss: -0.6868\n", + "Epoch 93 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.11it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3872, G Loss: -0.6940\n", + "Epoch 94 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.63it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3807, G Loss: -0.6942\n", + "Epoch 95 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.12it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3816, G Loss: -0.6941\n", + "Epoch 96 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3835, G Loss: -0.6933\n", + "Epoch 97 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3814, G Loss: -0.6963\n", + "Epoch 98 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.43it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3800, G Loss: -0.6879\n", + "Epoch 99 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.74it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3845, G Loss: -0.6889\n", + "Epoch 100 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.93it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3778, G Loss: -0.7008\n", + "Epoch 101 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.24it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3830, G Loss: -0.6888\n", + "Epoch 102 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3755, G Loss: -0.6938\n", + "Epoch 103 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.22it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3852, G Loss: -0.6948\n", + "Epoch 104 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.14it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3807, G Loss: -0.6966\n", + "Epoch 105 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.70it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3935, G Loss: -0.6921\n", + "Epoch 106 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.76it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.4002, G Loss: -0.6990\n", + "Epoch 107 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3825, G Loss: -0.6922\n", + "Epoch 108 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3974, G Loss: -0.6947\n", + "Epoch 109 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.04it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3838, G Loss: -0.6841\n", + "Epoch 110 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.17it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3806, G Loss: -0.6924\n", + "Epoch 111 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3895, G Loss: -0.6905\n", + "Epoch 112 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3871, G Loss: -0.6920\n", + "Epoch 113 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3833, G Loss: -0.6917\n", + "Epoch 114 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 13.00it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3867, G Loss: -0.6894\n", + "Epoch 115 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.75it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3931, G Loss: -0.6912\n", + "Epoch 116 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.80it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3885, G Loss: -0.6920\n", + "Epoch 117 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.76it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3897, G Loss: -0.6933\n", + "Epoch 118 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.70it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3856, G Loss: -0.6939\n", + "Epoch 119 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.45it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3902, G Loss: -0.6975\n", + "Epoch 120 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.64it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3781, G Loss: -0.6871\n", + "Epoch 121 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.61it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3979, G Loss: -0.6867\n", + "Epoch 122 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.72it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3786, G Loss: -0.6834\n", + "Epoch 123 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.34it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3884, G Loss: -0.6906\n", + "Epoch 124 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:06<00:00, 10.16it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3929, G Loss: -0.6936\n", + "Epoch 125 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 13.15it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3909, G Loss: -0.6930\n", + "Epoch 126 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3830, G Loss: -0.6906\n", + "Epoch 127 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3755, G Loss: -0.6879\n", + "Epoch 128 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3909, G Loss: -0.6956\n", + "Epoch 129 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.30it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3897, G Loss: -0.6947\n", + "Epoch 130 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3839, G Loss: -0.6909\n", + "Epoch 131 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.48it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3884, G Loss: -0.6919\n", + "Epoch 132 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.58it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3821, G Loss: -0.6938\n", + "Epoch 133 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 14.24it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.4008, G Loss: -0.6880\n", + "Epoch 134 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.23it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3897, G Loss: -0.6902\n", + "Epoch 135 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.92it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3850, G Loss: -0.6866\n", + "Epoch 136 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.26it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3873, G Loss: -0.6920\n", + "Epoch 137 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:06<00:00, 9.56it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3868, G Loss: -0.6988\n", + "Epoch 138 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.98it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3922, G Loss: -0.6919\n", + "Epoch 139 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.68it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3843, G Loss: -0.6935\n", + "Epoch 140 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3890, G Loss: -0.6911\n", + "Epoch 141 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3880, G Loss: -0.6893\n", + "Epoch 142 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.90it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3788, G Loss: -0.6932\n", + "Epoch 143 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3917, G Loss: -0.6935\n", + "Epoch 144 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.27it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3919, G Loss: -0.6877\n", + "Epoch 145 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.82it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3799, G Loss: -0.6903\n", + "Epoch 146 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:04<00:00, 13.84it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3833, G Loss: -0.6957\n", + "Epoch 147 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 13.15it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3920, G Loss: -0.6940\n", + "Epoch 148 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 11.67it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3836, G Loss: -0.6857\n", + "Epoch 149 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.89it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3925, G Loss: -0.6955\n", + "Epoch 150 / 150\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 66/66 [00:05<00:00, 12.71it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D Loss: 1.3828, G Loss: -0.6896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# note that the temperature is set to any value between 0 and 1.\n", + "g_losses, d_losses = train_gan_model(\n", + " gen,\n", + " disc,\n", + " gen_optimizer,\n", + " disc_optimizer,\n", + " train_loader,\n", + " epochs,\n", + " vocab_size,\n", + " device=device,\n", + " tau=temperature,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_curve(d_losses, g_losses, epochs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## generate fake samples\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "fake_labels = torch.randint(0, num_classes, (n_samples,), dtype=torch.long)\n", + "z = torch.randn((n_samples, latent_dim))\n", + "\n", + "# print(\"random noise shape\", z.shape)\n", + "# set generator to eval mode\n", + "gen.eval()\n", + "\n", + "fake_data = gen(z.to(device), fake_labels.to(device)).detach().cpu()\n", + "\n", + "# print the generated data: if the data contains nan values, it means that there is gradient explosion, or other issues. To avoid such problems, change the termperature value to be between 0.1 and 0.5. Also, trying changing the learning rate to be between 5e-6 and 1e-4. Of course, this is just a suggestion. You might experiment with other values if you want, and report your findings.\n", + "# print(fake_data[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "array([[319, 267, 98, 273, 158, 191, 26, 114, 35, 193, 280, 102, 150,\n", + " 268, 81, 250, 260, 64, 145, 88, 53, 256, 34, 275, 231, 11,\n", + " 63, 62, 232, 194, 144, 133, 255, 38, 255, 228, 153, 265, 130,\n", + " 311, 146, 168, 197, 226, 294, 314, 9, 100, 180, 28, 87, 273,\n", + " 0, 15, 162, 149, 128, 273, 95, 307, 156, 307, 241, 159, 165,\n", + " 129, 68, 65, 171, 98, 304, 4, 142, 325, 18, 18, 297, 5,\n", + " 249, 164, 279, 76, 235, 263, 325, 131, 0, 183, 197, 331, 300,\n", + " 18, 120, 65, 31, 270, 179, 318, 119, 173],\n", + " [111, 136, 83, 50, 130, 225, 241, 201, 328, 269, 94, 98, 59,\n", + " 275, 178, 140, 72, 245, 15, 301, 23, 93, 219, 30, 48, 105,\n", + " 162, 303, 49, 230, 148, 236, 337, 106, 317, 139, 99, 106, 294,\n", + " 30, 70, 264, 306, 9, 305, 291, 53, 19, 158, 309, 47, 43,\n", + " 171, 168, 298, 313, 279, 279, 36, 296, 8, 124, 25, 124, 192,\n", + " 5, 184, 107, 118, 122, 220, 289, 299, 284, 318, 64, 130, 258,\n", + " 294, 335, 294, 153, 26, 172, 236, 299, 341, 145, 93, 182, 115,\n", + " 253, 222, 336, 155, 22, 219, 179, 35, 214]])\n" + ] + } + ], + "source": [ + "# get the generated samples as tokens (this are a sequence tokens or words / characters, represented by integers .)\n", + "from pprint import pprint\n", + "\n", + "fake_samples = torch.argmax(fake_data, dim=-1).cpu().numpy()\n", + "\n", + "# now, let's see two generated sequences\n", + "pprint(fake_samples[:2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Now, we can generate from generated tokens (i.e., sequence)\n", + "\n", + "` To do so, we can use the sequence_to_graph() function given in the preprocess_data.py`\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the generated samples into a networkx graph and also pytorch_geometric graph data object\n", + "networkx_graph, pytorch_geometric_data = sequence_to_graph(fake_samples[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# you can see the networkx graph we generated\n", + "nx.draw(networkx_graph, with_labels=True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Remaining Steps:\n", + "\n", + "```\n", + "1 - generate many fake samples (sequences and their corresponding labels),\n", + "\n", + "2 - add these fake sequences to train_data sequences, and add their fake_labels (benign or malign) to the trian_labels\n", + "\n", + "3 - train a new GCNModel and compare performance before and after adding fake samples.\n", + "\n", + "\n", + "```\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "graphganvenv", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..a089e32 --- /dev/null +++ b/utils.py @@ -0,0 +1,93 @@ +from typing import List + +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch.nn.functional as F +from sklearn.metrics import ( + accuracy_score, + f1_score, + matthews_corrcoef, + precision_score, + recall_score, +) + + +def get_device(): + """Get the preferred device: + check if there is a GPU available:NVIDIA GPU or MPS (Apple Silcon GPU) if available). + """ + + # check if there is nvidia or cuda gpu + if torch.cuda.is_available(): + return torch.device("cuda") + + # check if there is an apple silicon gpu + if torch.backends.mps.is_available(): + return torch.device("mps") + + # otherwise use the cpu + return torch.device("cpu") + + +def plot_loss_curve(d_losses: List[float], g_losses: List[float], EPOCHS: int) -> None: + """Plot loss curve of critic and generator. + + Args: + d_losses (List[float]): List of Discriminator losses. + g_losses (List[float]): List of generator losses. + EPOCHS (int): Total number of epochs. + """ + # normalize losses to get a nice graph + gen_losses = np.asarray(g_losses) + critic_losses = np.asarray(d_losses) + + gen_losses = (gen_losses - gen_losses.min()) / (gen_losses.max() - gen_losses.min()) + critic_losses = np.asarray(d_losses) + + critic_losses = (critic_losses - critic_losses.min()) / ( + critic_losses.max() - critic_losses.min() + ) + plt.figure(figsize=(20, 10)) + x = range(1, EPOCHS + 1) + plt.plot(x, critic_losses, color="red", label="Discriminator Loss") + plt.plot(x, gen_losses, color="blue", label="Generator Loss") + plt.xlabel("Epoch") + plt.ylabel("Loss Curve") + plt.legend() + plt.savefig("loss_curve.png") + plt.show() + + +def evaluate_gcn_model(gcn_model, graph_val_loader, vocab_size, device): + gcn_model.eval() + # val_losses = [] + # val_f1_scores = [] + + y_true = [] + y_pred = [] + + with torch.no_grad(): + for data in graph_val_loader: + x = data.x[0].to(device) + x = F.one_hot(x, num_classes=vocab_size).float() + edge_index = data.edge_index.to(device) + edge_weight = data.weight.float().to(device) + batch = data.batch.to(device) + + out = gcn_model(x, edge_index, edge_weight, batch) + # loss = F.cross_entropy(out, data.y) + # val_losses.append(loss.item()) + + preds = out.argmax(dim=1).cpu().numpy() + y_true.extend(data.y.cpu().numpy()) + y_pred.extend(preds) + + print("GCN performance:") + print(f"Accuracy: {accuracy_score(y_true, y_pred):.4f}") + print(f"Precision: {precision_score(y_true, y_pred, average='macro'):.4f}") + print(f"Recall: {recall_score(y_true, y_pred, average='macro'):.4f}") + print( + f"F1 score: {f1_score(y_true, y_pred, average='macro', zero_division=0.0):.4f}" + ) + print(f"MCC: {matthews_corrcoef(y_true, y_pred):.4f}")