Stacked denoising(deep) Autoencoder

SdA.py

import chainer
import chainer.functions as F
import chainer.optimizers as Opt
import numpy
from glob import iglob
import cv2


## model definition
# layers
enc_layer = [
    F.Linear(10000, 2000),
    F.Linear(2000, 300),
    F.Linear(300, 100),
]

dec_layer = [
    F.Linear(100, 300),
    F.Linear(300, 2000),
    F.Linear(2000, 10000)
]

model = chainer.FunctionSet(
    enc1=enc_layer[0],
    enc2=enc_layer[1],
    enc3=enc_layer[2],
    dec1=dec_layer[0],
    dec2=dec_layer[1],
    dec3=dec_layer[2],
).to_gpu()

layerwise = [
    chainer.FunctionSet(enc=enc_layer[0], dec=dec_layer[2]).to_gpu(),
    chainer.FunctionSet(enc=enc_layer[1], dec=dec_layer[1]).to_gpu(),
    chainer.FunctionSet(enc=enc_layer[2], dec=dec_layer[0]).to_gpu(),
]


def encode(x, layer, train):
    if train:
        x = F.dropout(x, ratio=0.2)

    if layer == 0:
        return x

    h = F.sigmoid(enc_layer[0](x))
    if layer == 1:
        return h

    h = F.sigmoid(enc_layer[1](h))
    if layer == 2:
        return h

    h = F.sigmoid(enc_layer[2](h))
    if layer == 3:
        return h

    h = F.sigmoid(enc_layer[3](h))
    if layer == 4:
        return h

chainer.cuda.get_device(0).use()

# data に学習データを放り込む
data = numpy.array(...)
N = len(data)

batchsize = 50
opt = Opt.Adam()

for epoch in range(2000):
    print('epoch : %d' % (epoch + 1))
    with open('dae.log', mode='a') as f:
        f.write("\n%d " % (epoch + 1))

    perm = numpy.random.permutation(N)
    data = data[perm]

    for l in range(1, 4):
        opt.setup(layerwise[l - 1])

        sum_err = 0.

        for i in range(0, N, batchsize):
            x_batch = chainer.cuda.cupy.asarray(data[perm[i:i + batchsize]])
            x = chainer.Variable(x_batch)
            targ = encode(x, l - 1, train=True)
            enc = encode(x, l, train=True)
            y = F.dropout(F.sigmoid(dec_layer[3 - l](enc)), train=True)

            opt.zero_grads()
            err = F.mean_squared_error(y, targ)
            err.backward()
            opt.update()

            sum_err += float(err.data) * len(x_batch)

        sum_err /= N
        print("\t%d %f" % (l, sum_err))
        with open('dae.log', mode='a') as f:
            f.write("%d %f" % (l, sum_err))

    param = numpy.array(model.to_cpu().parameters)
    numpy.save('dae.param.npy', param)
    model.to_gpu()