def __init__(self, alpha: float, beta_vgg:float, beta_pix: float, context=None) -> None:
self._alpha = alpha
self._bce = SigmoidBCELoss()
self._beta_vgg = beta_vgg
self._beta_pix = beta_pix
self._l1 = L1Loss()
self._vgg = VggLoss(context)
def __init__(self, weight=100, batch_axis=0, **kwargs):
"""
:param weight: for l1 loss
:param batch_axis:
:param kwargs:
"""
super(GeneratorCriterion, self).__init__(weight, batch_axis, **kwargs)
self.bce_loss = SigmoidBinaryCrossEntropyLoss(from_sigmoid=True,
batch_axis=batch_axis)
self.l1_loss = L1Loss(weight=weight, batch_axis=0)
def get_optimizer(self):
trainer_actor = gluon.Trainer(
self.actor.collect_params(), 'adadelta', {
'learning_rate': self.hparams.actor_learning_rate,
'rho': 0.99,
'epsilon': 0.01
})
trainer_critic = gluon.Trainer(
self.critic.collect_params(), 'adadelta', {
'learning_rate': self.hparams.actor_learning_rate,
'rho': 0.99,
'epsilon': 0.01
})
loss_actor = CrossEntropy()
loss_critic = L1Loss()
return trainer_actor, loss_actor, trainer_critic, loss_critic
def __init__(self, context) -> None:
self.vgg19 = vision.vgg19(pretrained=True, ctx=context)
self.vgg_layer = 22
self._l1 = L1Loss()
from mxnet.gluon.loss import L1Loss, L2Loss
from data import AsianFaceDatasets, IMDBWIKIDatasets
from model import Net
import math
epoches = 60
lr = 0.001
mom = 0.9
weight_decay = 0.0005
data_ctx = mx.gpu(0)
model_ctx = mx.gpu(0)
scale = nd.arange(0, 101, ctx=model_ctx).reshape((101, 1))
l1_loss = L1Loss()
# l1_loss = L2Loss()
net = Net()
# training_datasets = AsianFaceDatasets(csv_path='/home/gdshen/datasets/face/asian/train.csv',
# img_dir='/home/gdshen/datasets/face/asian/images')
# test_datasets = AsianFaceDatasets(csv_path='/home/gdshen/datasets/face/asian/test.csv',
# img_dir='/home/gdshen/datasets/face/asian/images', train=False)
training_datasets = IMDBWIKIDatasets(
csv_path='/home/gdshen/datasets/face/processed/train.csv', train=True)
test_datasets = IMDBWIKIDatasets(
csv_path='/home/gdshen/datasets/face/processed/test.csv', train=False)
def evaluate_accracy(data_iterator, net):
def __init__(self, alpha: float, beta: float) -> None:
self._alpha = alpha
self._bce = SigmoidBCELoss()
self._beta = beta
self._l1 = L1Loss()
def __init__(self, context) -> None:
# self.resizer_224 = mx.gluon.data.vision.transforms.Resize(224)
self.vgg19 = vision.vgg19(pretrained=True, ctx=context)
self.vgg_layer = 22
self._l1 = L1Loss()
def __init__(
self,
dir_list,
test_dir_list,
width=28,
height=28,
channel=1,
initializer=None,
batch_size=40,
learning_rate=0.0002,
ctx=mx.gpu(),
discriminative_model=None,
generative_model=None,
re_encoder_model=None,
):
'''
Init.
If you are not satisfied with this simple default setting,
delegate `discriminative_model` and `generative_model` designed by yourself.
Args:
dir_list: `list` of `str` of path to image files.
test_dir_list: `list` of `str` of path to image files for test.
width: `int` of image width.
height: `int` of image height.
channel: `int` of image channel.
initializer: is-a `mxnet.initializer` for parameters of model.
If `None`, it is drawing from the Xavier distribution.
batch_size: `int` of batch size.
learning_rate: `float` of learning rate.
ctx: `mx.gpu()` or `mx.cpu()`.
discriminative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.discriminative_model.DiscriminativeModel`.
generative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.generative_model.GenerativeModel`.
re_encoder_model: is-a `HybridBlock`.
'''
image_extractor = ImageExtractor(width=width,
height=height,
channel=channel,
ctx=ctx)
unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1 / 1000,
noiseable_data=GaussNoise(sigma=1e-08, mu=0.0),
)
test_unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=test_dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1 / 1000,
noiseable_data=GaussNoise(sigma=1e-08, mu=0.0),
)
true_sampler = TrueSampler()
true_sampler.iteratorable_data = unlabeled_image_iterator
condition_sampler = ConditionSampler()
condition_sampler.true_sampler = true_sampler
computable_loss = L2NormLoss()
if discriminative_model is None:
output_nn = NeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
units_list=[1],
dropout_rate_list=[0.0],
optimizer_name="SGD",
activation_list=["sigmoid"],
hidden_batch_norm_list=[None],
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
output_no_bias_flag=True,
all_no_bias_flag=True,
not_init_flag=False,
)
d_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(2, 2),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=output_nn,
hidden_dropout_rate_list=[
0.5,
0.5,
],
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
optimizer_name="SGD",
hidden_activation_list=[
"relu",
"relu",
],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
discriminative_model = DiscriminativeModel(
model=d_model,
initializer=None,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(discriminative_model, DiscriminativeModel) is False:
raise TypeError(
"The type of `discriminative_model` must be `DiscriminativeModel`."
)
if re_encoder_model is None:
re_encoder_model = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2D`.
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=[
"relu",
"relu",
],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[
0.5,
0.5,
],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
if generative_model is None:
encoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2D`.
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=[
"relu",
"relu",
],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[
0.5,
0.5,
],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
decoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
Conv2DTranspose(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2DTranspose(
channels=channel,
kernel_size=6,
strides=(2, 2),
padding=(0, 0),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=["relu", "tanh"],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[0.5, 0.0],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), None],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
g_model = ConvolutionalAutoEncoder(
# is-a `ConvolutionalNeuralNetworks`.
encoder=encoder,
# is-a `ConvolutionalNeuralNetworks`.
decoder=decoder,
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
optimizer_name="SGD",
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
generative_model = GenerativeModel(
noise_sampler=UniformNoiseSampler(low=-1e-05,
high=1e-05,
batch_size=batch_size,
seq_len=0,
channel=channel,
height=height,
width=width,
ctx=ctx),
model=g_model,
initializer=None,
condition_sampler=condition_sampler,
conditonal_dim=1,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(generative_model, GenerativeModel) is False:
raise TypeError(
"The type of `generative_model` must be `GenerativeModel`."
)
ganomaly_controller = GanomalyController(
generative_model=generative_model,
re_encoder_model=re_encoder_model,
discriminative_model=discriminative_model,
advarsarial_loss=L2NormLoss(weight=0.015),
encoding_loss=L2NormLoss(weight=0.015),
contextual_loss=L1Loss(weight=0.5),
discriminator_loss=DiscriminatorLoss(weight=0.015),
feature_matching_loss=None,
optimizer_name="SGD",
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hybridize_flag=True,
scale=1.0,
ctx=ctx,
initializer=initializer,
)
self.ganomaly_controller = ganomaly_controller
self.test_unlabeled_image_iterator = test_unlabeled_image_iterator
.random_split(datasets["train"],
frac=[config["HYPER_PARAMS"]["TRAIN_SPLIT"],
1 - config["HYPER_PARAMS"]["TRAIN_SPLIT"]],
random_state=config["HYPER_PARAMS"]["SEED"],
shuffle=True)
# Dump data to memory
print("\nDumping data to memory...")
datasets["train"] = datasets["train"].compute(num_workers=cpu_count())
datasets["validation"] = datasets["validation"].compute(
num_workers=cpu_count())
datasets["test"] = datasets["test"].compute(num_workers=cpu_count())
print("Data dumped!")
# Define locals for MXNet
model_mgr: ModelManager = ModelManager(loss_fn=L1Loss(),
model_style=config["STYLE"].lower(),
writer=SummaryWriter(
logdir=config["PATH"]["LOGS"],
flush_secs=1))
# Prepare data
batch_data["train"] = model_mgr.get_batch_data(
data=datasets["train"],
workers=cpu_count(),
cols=config["COLUMNS"],
batch_size=config["HYPER_PARAMS"]["BATCH_SIZE"],
label="train")
batch_data["validation"] = model_mgr.get_batch_data(
data=datasets["validation"],
workers=cpu_count(),
