class AutoEncoder:
"""
Constract AutoEncoder by #input and #hidden
"""
def __init__(self, xn, hn):
self.model = FunctionSet(encode=F.Linear(xn, hn), decode=F.Linear(hn, xn))
def encode(self, x, train=True):
h = F.dropout(F.relu(self.model.encode(x)), train=train)
return h
def decode(self, h, train=True):
y = F.dropout(F.relu(self.model.decode(h)), train=train)
return y
def train_once(self, x_data):
x = Variable(x_data)
h = self.encode(x)
y = self.decode(h)
return F.mean_squared_error(x, y)#, F.accuracy(x, y)
def reconstract(self, x_data):
x = Variable(x_data)
h = self.encode(x, train=False)
y = self.decode(h, train=False)
return y.data
class ConvolutionalDenoisingAutoencoder():
def __init__(self, imgsize, n_in_channels, n_out_channels, ksize, stride=1, pad=0, use_cuda=False):
self.model = FunctionSet(
encode=F.Convolution2D(n_in_channels, n_out_channels, ksize, stride, pad),
decode=F.Linear(n_out_channels*(math.floor((imgsize+2*pad-ksize)/stride)+1)**2, n_in_channels*imgsize**2)
)
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return self.model.decode(x_var)
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
if self.use_cuda:
return cuda.to_cpu(p.data)
else:
return p.data
def cost(self, x_data):
x = Variable(x_data)
t = Variable(x_data.reshape(x_data.shape[0], x_data.shape[1]*x_data.shape[2]*x_data.shape[3]))
h = F.dropout(x)
h = self.encode(h)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
if self.use_cuda:
return float(cuda.to_cpu(loss.data))
else:
return loss.data
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
class DenoisingAutoencoder(SuperClass):
def __init__(self, n_in, n_hidden, n_epoch=20, batchsize=100, use_cuda=False):
super().__init__(n_epoch, batchsize, use_cuda)
self.model = FunctionSet(
encode=F.Linear(n_in, n_hidden),
decode=F.Linear(n_hidden, n_in)
)
self.registModel()
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return self.model.decode(x_var)
def predict(self, x_data):
x_data = self.procInput(x_data)
x = Variable(x_data)
p = self.encode(x)
return self.procOutput(p.data)
def cost(self, x_data):
x_data = self.procInput(x_data)
x = Variable(x_data)
t = Variable(x_data)
h = self.encode(F.dropout(t))
y = self.decode(h)
return self.procOutput(F.mean_squared_error(y, x))
def test(self, x_data):
x_data = self.procInput(x_data)
x = Variable(x_data)
t = Variable(x_data)
h = self.encode(t)
y = self.decode(h)
return self.procOutput(F.mean_squared_error(y, x))
def save(self, filedir, n_hidden, n_epoch, batchsize):
name = "SdA_"+ "layer"+str(n_hidden) + "_epoch"+str(n_epoch)
param = {}
param['W'] = self.model.encode.parameters[0]
param['b'] = self.model.encode.parameters[1]
pickle.dump(param, open(filedir+'/'+name+'.pkl', 'wb'), pickle.HIGHEST_PROTOCOL)
return
def load(self, filename):
if filename.find('.pkl')==-1:
filename = filename + '.pkl'
param = pickle.load(open(filename, 'rb'))
self.model.encode.parameters = (param['W'], param['b'])
return
class DenoisingAutoEncoder():
def __init__(self, n_in, n_hidden, use_cuda=False):
self.model = FunctionSet(encode=F.Linear(n_in, n_hidden),
decode=F.Linear(n_hidden, n_in))
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return F.sigmoid(self.model.decode(x_var))
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
return cuda.to_cpu(p.data)
def cost(self, x_data):
x = Variable(x_data)
t = Variable(x_data)
x_n = F.dropout(x)
h = self.encode(x_n)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
return float(cuda.to_cpu(loss.data))
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
class MNISTNet():
def __init__(self):
n_in = 28 * 28
n_hidden = 100
self.model = FunctionSet(
encode=F.Linear(n_in, n_hidden),
decode=F.Linear(n_hidden, n_in)
)
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return F.sigmoid(self.model.decode(x_var))
def predict(self, x_data):
x = Variable(x_data)
p = self.encode(x)
return p.data
def cost(self, x_data, dropout=True):
x = Variable(x_data)
t = Variable(x_data)
if dropout:
x_n = F.dropout(x, ratio=0.4)
else:
x_n = x
h = self.encode(x_n)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
return float(loss.data)
class MNISTNet():
def __init__(self):
n_in = 28 * 28
n_hidden = 100
self.model = FunctionSet(encode=F.Linear(n_in, n_hidden),
decode=F.Linear(n_hidden, n_in))
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return F.sigmoid(self.model.decode(x_var))
def predict(self, x_data):
x = Variable(x_data)
p = self.encode(x)
return p.data
def cost(self, x_data, dropout=True):
x = Variable(x_data)
t = Variable(x_data)
if dropout:
x_n = F.dropout(x, ratio=0.4)
else:
x_n = x
h = self.encode(x_n)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
return float(loss.data)
class ConvolutionalDenoisingAutoencoder():
def __init__(self,
imgsize,
n_in_channels,
n_out_channels,
ksize,
stride=1,
pad=0,
use_cuda=False):
self.model = FunctionSet(
encode=F.Convolution2D(n_in_channels, n_out_channels, ksize,
stride, pad),
decode=F.Linear(
n_out_channels * (math.floor(
(imgsize + 2 * pad - ksize) / stride) + 1)**2,
n_in_channels * imgsize**2))
self.use_cuda = use_cuda
if self.use_cuda:
self.model.to_gpu()
self.optimizer = optimizers.Adam()
self.optimizer.setup(self.model.collect_parameters())
def encode(self, x_var):
return F.sigmoid(self.model.encode(x_var))
def decode(self, x_var):
return self.model.decode(x_var)
def predict(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
x = Variable(x_data)
p = self.encode(x)
if self.use_cuda:
return cuda.to_cpu(p.data)
else:
return p.data
def cost(self, x_data):
x = Variable(x_data)
t = Variable(
x_data.reshape(x_data.shape[0], x_data.shape[1] * x_data.shape[2] *
x_data.shape[3]))
h = F.dropout(x)
h = self.encode(h)
y = self.decode(h)
return F.mean_squared_error(y, t)
def train(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
self.optimizer.zero_grads()
loss = self.cost(x_data)
loss.backward()
self.optimizer.update()
if self.use_cuda:
return float(cuda.to_cpu(loss.data))
else:
return loss.data
def test(self, x_data):
if self.use_cuda:
x_data = cuda.to_gpu(x_data)
loss = self.cost(x_data)
return float(cuda.to_cpu(loss.data))
