def __init__(self):
super(SimplerCNN, self).__init__()
self.dropout2d_input = nn.Dropout2d(rate=0.3)
self.conv1 = nn.Conv2d(in_channels=3,
out_channels=15,
kernel_size=3,
stride=3,
padding=2)
self.relu1 = nn.LeakyRelu()
self.conv2 = nn.Conv2d(in_channels=15,
out_channels=30,
kernel_size=3,
stride=3,
padding=3)
self.relu2 = nn.LeakyRelu()
self.dropout2d_conv1 = nn.Dropout2d(rate=0.5)
self.conv3 = nn.Conv2d(in_channels=30, out_channels=40, kernel_size=4)
self.relu3 = nn.LeakyRelu()
self.flatten = nn.Flatten()
self.dropout2d_conv2 = nn.Dropout2d(rate=0.2)
self.linear = nn.Linear(in_dimension=360, out_dimension=180)
self.relu4 = nn.LeakyRelu()
self.bn1 = nn.BatchNorm()
self.dropout3 = nn.Dropout(rate=0.3)
self.linear2 = nn.Linear(in_dimension=180, out_dimension=10)
self.bn2 = nn.BatchNorm()
self.softmax = nn.Softmax()
self.set_forward()
def __init__(self, image_size=64, width=64, zdim=128):
super(SketchVAE.ImageEncoder, self).__init__()
self.zdim = zdim
self.net = th.nn.Sequential(
th.nn.Conv2d(4, width, 5, padding=2),
th.nn.InstanceNorm2d(width),
th.nn.ReLU(inplace=True),
# 64x64
th.nn.Conv2d(width, width, 5, padding=2),
th.nn.InstanceNorm2d(width),
th.nn.ReLU(inplace=True),
# 64x64
th.nn.Conv2d(width, 2 * width, 5, stride=1, padding=2),
th.nn.InstanceNorm2d(2 * width),
th.nn.ReLU(inplace=True),
# 32x32
th.nn.Conv2d(2 * width, 2 * width, 5, stride=2, padding=2),
th.nn.InstanceNorm2d(2 * width),
th.nn.ReLU(inplace=True),
# 16x16
th.nn.Conv2d(2 * width, 2 * width, 5, stride=2, padding=2),
th.nn.InstanceNorm2d(2 * width),
th.nn.ReLU(inplace=True),
# 16x16
th.nn.Conv2d(2 * width, 2 * width, 5, stride=2, padding=2),
th.nn.InstanceNorm2d(2 * width),
th.nn.ReLU(inplace=True),
# 8x8
th.nn.Conv2d(2 * width, 2 * width, 5, stride=2, padding=2),
th.nn.InstanceNorm2d(2 * width),
th.nn.ReLU(inplace=True),
# 4x4
modules.Flatten(),
th.nn.Linear(4 * 4 * 2 * width, 2 * zdim))
def conv_layer(x):
"""
the derivative check in the gradient checker relates to the input of the function
hence, the input should be z - since the backward step computes @loss / @z
"""
conv1 = nn.Conv2d(in_channels=1, out_channels=2, kernel_size=2)
relu1 = nn.Relu()
conv2 = nn.Conv2d(in_channels=2, out_channels=4, kernel_size=2)
relu2 = nn.Relu()
flatten = nn.Flatten()
linear = nn.Linear(4, 2)
softmax = nn.Softmax()
# forward pass
a = relu1(conv1(x))
a = relu2(conv2(a))
a_flatten = flatten(a)
dist = softmax(linear(a_flatten))
# backward
labels = np.zeros(dist.shape)
labels[:, 1] = 1
loss = -np.log(np.sum(dist * labels, axis=1))
softmax_grad = softmax.backward(labels)
linear_grad = linear.backward(softmax_grad)
flatten_grad = flatten.backward(linear_grad)
relu2_grad = relu2.backward(flatten_grad)
conv2_grad = conv2.backward(relu2_grad)
relu1_grad = relu1.backward(conv2_grad)
conv1_grad = conv1.backward(relu1_grad)
return loss, conv1_grad
def conv(b):
"""
the derivative check in the gradient checker relates to the input of the function
hence, the input should be z - since the backward step computes @loss / @z
"""
# simulate end of classification
conv = nn.Conv2d(in_channels=1, out_channels=3, kernel_size=2)
relu = nn.Relu()
flatten = nn.Flatten()
linear = nn.Linear(in_dimension=12, out_dimension=4)
softmax = nn.Softmax()
conv.set_biases(b.reshape(3, 1))
# forward
a = flatten(relu(conv(x)))
dist = softmax(linear(a))
# backward
labels = np.zeros(dist.shape)
labels[:, 1] = 1
loss = -np.log(np.sum(dist * labels, axis=1))
softmax_grad = softmax.backward(labels)
linear_grad = linear.backward(softmax_grad)
flatten_grad = flatten.backward(linear_grad)
relu_grad = relu.backward(flatten_grad)
conv_grad = conv.backward(relu_grad)
b_grad = conv.b_grad
return loss, b_grad
def __init__(self):
super(SimpleCNN, self).__init__()
self.conv1 = nn.Conv2d(in_channels=3,
out_channels=6,
kernel_size=3,
stride=3,
padding=2)
self.tanh1 = nn.Tanh()
self.conv2 = nn.Conv2d(in_channels=6,
out_channels=10,
kernel_size=3,
stride=3,
padding=3)
self.tanh2 = nn.Tanh()
self.dropout2d = nn.Dropout2d(rate=0.5)
self.flatten = nn.Flatten()
self.linear = nn.Linear(in_dimension=360, out_dimension=10)
self.softmax = nn.Softmax()
self.set_forward()
def flatten(x):
flatten_ = nn.Flatten()
linear = nn.Linear(in_dimension=48, out_dimension=4)
softmax = nn.Softmax()
# forward
flatten_x = flatten_(x)
dist = softmax(linear(flatten_x))
# backward
labels = np.zeros(dist.shape)
labels[:, 1] = 1
loss = -np.log(np.sum(dist * labels, axis=1))
softmax_grad = softmax.backward(labels)
linear_grad = linear.backward(softmax_grad)
flatten_grad = flatten_.backward(linear_grad)
return loss, flatten_grad
def __init__(self, conditional=False, width=64, color_output=False):
super(Discriminator, self).__init__()
self.conditional = conditional
sn = th.nn.utils.spectral_norm
num_chan_in = 3 if color_output else 1
self.net = th.nn.Sequential(
th.nn.Conv2d(num_chan_in, width, 3, padding=1),
th.nn.LeakyReLU(0.2, inplace=True),
th.nn.Conv2d(width, 2*width, 4, padding=1, stride=2),
th.nn.LeakyReLU(0.2, inplace=True),
# 16x16
sn(th.nn.Conv2d(2*width, 2*width, 3, padding=1)),
th.nn.LeakyReLU(0.2, inplace=True),
sn(th.nn.Conv2d(2*width, 4*width, 4, padding=1, stride=2)),
th.nn.LeakyReLU(0.2, inplace=True),
# 8x8
sn(th.nn.Conv2d(4*width, 4*width, 3, padding=1)),
th.nn.LeakyReLU(0.2, inplace=True),
sn(th.nn.Conv2d(4*width, width*4, 4, padding=1, stride=2)),
th.nn.LeakyReLU(0.2, inplace=True),
# 4x4
sn(th.nn.Conv2d(4*width, 4*width, 3, padding=1)),
th.nn.LeakyReLU(0.2, inplace=True),
sn(th.nn.Conv2d(4*width, width*4, 4, padding=1, stride=2)),
th.nn.LeakyReLU(0.2, inplace=True),
# 2x2
modules.Flatten(),
th.nn.Linear(width*4*2*2, 1),
)
def roar_kar(keep, random=False, train_only=False):
logdir = 'tf_logs/standard/'
def get_savedir():
savedir = logdir.replace('tf_logs', 'KAR' if keep else 'ROAR')
if not os.path.exists(savedir):
os.makedirs(savedir)
return savedir
# ratio = 0.1
percentiles = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
attribution_methods = ['normal', 'LRP', 'proposed_method']
if not train_only:
DNN = model_io.read('../models/MNIST/LeNet-5.nn')
for v in attribution_methods:
batch_size = 128
print("{} Step is start".format(v))
if random:
print("{} percentile Remove".format(v))
occlude_dataset(DNN=DNN,
attribution=v,
percentiles=percentiles,
random=True,
keep=keep,
batch_size=batch_size,
savedir=get_savedir())
else:
print("{} Random Remove".format(v))
occlude_dataset(DNN=DNN,
attribution=v,
percentiles=percentiles,
random=False,
keep=keep,
batch_size=batch_size,
savedir=get_savedir())
print("{} : occlude step is done".format(v))
print("ress record")
ress = {k: [] for k in attribution_methods}
for _ in range(3):
for v in attribution_methods:
res = []
for p in percentiles:
occdir = get_savedir() + '{}_{}_{}.pickle'.format('{}', v, p)
occdir_y = get_savedir() + '{}_{}_{}_{}.pickle'.format(
'{}', v, p, 'label')
data_train = unpickle(occdir.format('train'))
# data_test = unpickle(occdir.format('test'))
Xtrain = np.array(data_train)
Ytrain = unpickle(occdir_y.format('train'))
Ytrain = np.array(Ytrain)
Xtest = data_io.read('../data/MNIST/test_images.npy')
Ytest = data_io.read('../data/MNIST/test_labels.npy')
print("check : {}".format(Ytrain.shape))
Xtest = scale(Xtest)
Xtest = np.reshape(Xtest, [Xtest.shape[0], 28, 28, 1])
Xtest = np.pad(Xtest, ((0, 0), (2, 2), (2, 2), (0, 0)),
'constant',
constant_values=(-1., ))
Ix = Ytest[:, 0].astype(int)
Ytest = np.zeros([Xtest.shape[0], np.unique(Ytest).size])
Ytest[np.arange(Ytest.shape[0]), Ix] = 1
print(occdir)
# DNN = model_io.read('../models/MNIST/LeNet-5.nn')
DNN = modules.Sequential([
modules.Convolution(filtersize=(5,5,1,10),stride = (1,1)),\
modules.Rect(),\
modules.SumPool(pool=(2,2),stride=(2,2)),\
modules.Convolution(filtersize=(5,5,10,25),stride = (1,1)),\
modules.Rect(),\
modules.SumPool(pool=(2,2),stride=(2,2)),\
modules.Convolution(filtersize=(4,4,25,100),stride = (1,1)),\
modules.Rect(),\
modules.SumPool(pool=(2,2),stride=(2,2)),\
modules.Convolution(filtersize=(1,1,100,10),stride = (1,1)),\
modules.Flatten()
])
print("training...")
DNN.train(X=Xtrain,\
Y=Ytrain,\
Xval=Xtest,\
Yval=Ytest,\
iters=10**5,\
lrate=0.0001,\
# status = 2,\
batchsize = 128
)
# ypred = DNN.forward(Xtest)
acc = np.mean(
np.argmax(DNN.forward(Xtest), axis=1) == np.argmax(Ytest,
axis=1))
del DNN
print('metric model test accuracy is: {:0.4f}'.format(acc))
res.append(acc)
print("End of {}:training, accuracy...".format(_))
ress[v].append(res)
print("metric...")
res_mean = {v: np.mean(v, axis=0) for v in ress.item()}
print(res_mean)
return res_mean
def flatten(layer):
module = modules.Flatten()
return module, None
def globalaveragepooling2D(layer):
h, w = layer.input_shape[1:3]
module = modules.AveragePool(pool=(h, w), stride=(1, 1))
return module, modules.Flatten()
# transfer pixel values from [0 255] to [-1 1] to satisfy the expected input / training paradigm of the model
Xtrain = Xtrain / 127.5 - 1
Xtest = Xtest / 127.5 - 1
# transform numeric class labels to vector indicator for uniformity. assume presence of all classes within the label set
I = Ytrain[:,0].astype(int)
Ytrain = np.zeros([Xtrain.shape[0],np.unique(Ytrain).size])
Ytrain[np.arange(Ytrain.shape[0]),I] = 1
I = Ytest[:,0].astype(int)
Ytest = np.zeros([Xtest.shape[0],np.unique(Ytest).size])
Ytest[np.arange(Ytest.shape[0]),I] = 1
nn = modules.Sequential(
[
modules.Flatten(),
modules.Linear(784, 1296),
modules.Rect(),
modules.Linear(1296,1296),
modules.Rect(),
modules.Linear(1296,1296),
modules.Rect(),
modules.Linear(1296, 10),
modules.SoftMax()
]
)
nn.train(Xtrain, Ytrain, Xtest, Ytest, batchsize=64, iters=35000, status=1000)
acc = np.mean(np.argmax(nn.forward(Xtest), axis=1) == np.argmax(Ytest, axis=1))
if not np == numpy: # np=cupy
acc = np.asnumpy(acc)