|
import logging
|
|
import datasets
|
|
from datasets import load_dataset
|
|
import pandas as pd
|
|
import matplotlib.pyplot as plt
|
|
import seaborn as sns
|
|
from datasets import load_metric
|
|
import transformers
|
|
import torch
|
|
import io
|
|
import torch.nn.functional as F
|
|
import random
|
|
import numpy as np
|
|
import time
|
|
import math
|
|
import datetime
|
|
import torch.nn as nn
|
|
from torch.utils.data import Dataset,TensorDataset, DataLoader, RandomSampler, SequentialSampler
|
|
from transformers import (
|
|
AutoModel,
|
|
AutoConfig,
|
|
AutoModelForSequenceClassification,
|
|
AutoTokenizer,
|
|
DataCollatorWithPadding,
|
|
default_data_collator,
|
|
set_seed,
|
|
get_constant_schedule_with_warmup,
|
|
Trainer,TrainingArguments,EarlyStoppingCallback)
|
|
from datasets import Dataset
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
import sys
|
|
|
|
|
|
|
|
|
|
|
|
class Generator(nn.Module):
|
|
def __init__(self, noise_size=100, output_size=512, hidden_sizes=[512], dropout_rate=0.1):
|
|
super(Generator, self).__init__()
|
|
layers = []
|
|
hidden_sizes = [noise_size] + hidden_sizes
|
|
for i in range(len(hidden_sizes)-1):
|
|
layers.extend([nn.Linear(hidden_sizes[i], hidden_sizes[i+1]), nn.LeakyReLU(0.2, inplace=True), nn.Dropout(dropout_rate)])
|
|
|
|
layers.append(nn.Linear(hidden_sizes[-1],output_size))
|
|
self.layers = nn.Sequential(*layers)
|
|
|
|
def forward(self, noise):
|
|
output_rep = self.layers(noise)
|
|
return output_rep
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Discriminator(nn.Module):
|
|
def __init__(self, input_size=512, hidden_sizes=[512], num_labels=2, dropout_rate=0.3):
|
|
super(Discriminator, self).__init__()
|
|
self.input_dropout = nn.Dropout(p=dropout_rate)
|
|
layers = []
|
|
hidden_sizes = [input_size] + hidden_sizes
|
|
for i in range(len(hidden_sizes)-1):
|
|
layers.extend([nn.Linear(hidden_sizes[i], hidden_sizes[i+1]), nn.LeakyReLU(0.2, inplace=True), nn.Dropout(dropout_rate)])
|
|
|
|
self.layers = nn.Sequential(*layers)
|
|
self.logit = nn.Linear(hidden_sizes[-1],num_labels+1)
|
|
self.softmax = nn.Softmax(dim=-1)
|
|
|
|
def forward(self, input_rep):
|
|
input_rep = self.input_dropout(input_rep)
|
|
last_rep = self.layers(input_rep)
|
|
logits = self.logit(last_rep)
|
|
probs = self.softmax(logits)
|
|
return last_rep, logits, probs |
