def test_seqlayer():
network = N.Network()
network.debug = True
class ConvNN(layer.Layer, metaclass=compose.SeqLayer,
seq=[Conv2d, act.Relu, pooling.Pooling],
yaml_tag=u'!ConvNN',
type_name='ConvNN'):
def __init__(self, feature_map_multiplier=1):
super().__init__()
self.bases[0] = Conv2d(feature_map_multiplier=feature_map_multiplier)
network.setInput(RawInput((1, 28,28)))
network.append(ConvNN(feature_map_multiplier=32))
network.append(ConvNN(feature_map_multiplier=2))
network.append(ConvNN(feature_map_multiplier=2))
network.append(reshape.Flatten())
network.append(fullconn.FullConn(input_feature=1152, output_feature=1152*2))
network.append(act.Relu())
network.append(fullconn.FullConn(input_feature=1152*2, output_feature=10))
network.append(output.SoftMax())
network.build()
trX, trY, teX, teY = l.load_mnist()
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def test_maxout():
network = N.Network()
network.setInput(RawInput((1, 28, 28)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=128))
network.append(pooling.FeaturePooling(4))
network.append(pooling.Pooling((2, 2)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=8))
network.append(pooling.FeaturePooling(4))
network.append(pooling.Pooling((2, 2)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=8))
network.append(pooling.FeaturePooling(4))
network.append(pooling.GlobalPooling())
network.append(fullconn.FullConn(input_feature=128, output_feature=10))
network.append(output.SoftMax())
network.build()
trX, trY, teX, teY = l.load_mnist()
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(
np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def test_predictBatchSize():
"""
Test batch size works for perdictor.
"""
n = N.Network()
n.batchSize = 2
n.inputSizeChecker = [1, 1]
x = T.fmatrix()
y = T.switch(T.gt(x, 0), 1, 0)
f = theano.function([x], y, allow_input_downcast=True)
n.predicter = f
tx = np.array([[-0.27540332], [-0.76737626], [0.84122449], [-1.96092991],
[-0.44198351], [0.79166672], [0.87340424], [0.04555511],
[-2.11510706], [-0.10966502], [0.54762297], [-1.56990211],
[-0.61545427], [1.11211698], [-0.66220848], [0.11964702],
[-2.15263133], [-1.8672312], [0.22093941], [-0.46957548]])
ty = np.array([[0], [0], [1], [0], [0], [1], [1], [1], [0], [0], [1], [0],
[0], [1], [0], [1], [0], [0], [1], [0]])
tlen = 20
assert (ty == n.predict(tx)).all()
assert (ty[:(tlen - 1), :] == n.predict(tx[:(tlen - 1), :])).all()
def test2():
network = N.Network()
network.debug = True
#network.setInput(RawInput((1, 28,28)))
#network.append(conv.Conv2d(feature_map_multiplier=32))
#network.append(act.Relu())
#network.append(pooling.Pooling())
#network.append(conv.Conv2d(feature_map_multiplier=2))
#network.append(act.Relu())
#network.append(pooling.Pooling())
#network.append(conv.Conv2d(feature_map_multiplier=2))
#network.append(act.Relu())
#network.append(pooling.Pooling())
#network.append(reshape.Flatten())
#network.append(fullconn.FullConn(input_feature=1152, output_feature=1152*2))
#network.append(act.Relu())
#network.append(fullconn.FullConn(input_feature=1152*2, output_feature=10))
#network.append(output.SoftMax())
li = RawInput((1, 28,28))
network.setInput(li)
lc1 = conv.Conv2d(feature_map_multiplier=32)
la1 = act.Relu()
lp1 = pooling.Pooling()
lc2 = conv.Conv2d(feature_map_multiplier=2)
la2 = act.Relu()
lp2 = pooling.Pooling()
lc3 = conv.Conv2d(feature_map_multiplier=2)
la3 = act.Relu()
lp3 = pooling.Pooling()
lf = reshape.Flatten()
lfc1 = fullconn.FullConn(input_feature=1152, output_feature=1152*2)
la4 = act.Relu()
lfc2 = fullconn.FullConn(input_feature=1152*2, output_feature=10)
lsm = output.SoftMax()
network.connect(li, lc1)
network.connect(lc1, la1)
network.connect(la1, lp1)
network.connect(lp1, lc2)
network.connect(lc2, la2)
network.connect(la2, lp2)
network.connect(lp2, lc3)
network.connect(lc3, la3)
network.connect(la3, lp3)
network.connect(lp3, lf)
network.connect(lf, lfc1)
network.connect(lfc1, la4)
network.connect(la4, lfc2)
network.connect(lfc2, lsm)
network.build()
trX, trY, teX, teY = l.load_mnist()
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def test1():
network = N.Network()
network.debug = True
network.setInput((28, 28))
network.append(
conv.Conv2d(filter=(3, 3), input_feature=1, output_feature=32))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=32, output_feature=32))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=32, output_feature=32))
network.append(act.Relu())
network.append(pooling.Pooling((2, 2)))
network.append(
conv.Conv2d(filter=(3, 3), input_feature=32, output_feature=64))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=64, output_feature=64))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=64, output_feature=64))
network.append(act.Relu())
network.append(pooling.Pooling((2, 2)))
network.append(
conv.Conv2d(filter=(3, 3), input_feature=64, output_feature=128))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=128, output_feature=128))
network.append(act.Relu())
network.append(
conv.Conv2d(filter=(3, 3), input_feature=128, output_feature=128))
network.append(act.Relu())
network.append(pooling.Pooling((2, 2)))
network.append(reshape.Flatten())
network.append(
fullconn.FullConn(input_feature=1152, output_feature=1152 * 2))
network.append(act.Relu())
network.append(fullconn.FullConn(input_feature=1152 * 2,
output_feature=10))
network.append(output.SoftMax())
#network.setCost(N.CategoryCrossEntropy)
network.build()
f = h5py.File('/hdd/home/yueguan/workspace/data/mnist/mnist.hdf5', 'r')
trX = f['x_train'][:, :].reshape(-1, 1, 28, 28)
teX = f['x_test'][:, :].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(np.argmax(teY, axis=1) == network.predict(teX)))
def test_unet():
n = N.Network()
def unet_dag():
x1 = DAGPlan.input()
y1 = Relu(Conv2d(Relu(Conv2d(x1))))
x2 = Pooling(y1)
y2 = Relu(Conv2d(Relu(Conv2d(x2))))
x3 = Pooling(y2)
y3 = Relu(Conv2d(Relu(Conv2d(x3))))
#x4 = y2 // conv.UpConv2d(y3)
x4 = CropConcat(y2, UpConv2d(y3))
y4 = Relu(Conv2d(Relu(Conv2d(x4))))
#x5 = y1 // conv.UpConv2d(y4)
x5 = CropConcat(y1, UpConv2d(y4))
y5 = Relu(Conv2d(Relu(Conv2d(x5))))
return y5
dagplan = unet_dag()
class UNet(Layer,
metaclass=DAG,
dag=dagplan,
yaml_tag=u'!UNet',
type_name='UNet'):
pass
n.setInput(RawInput((1, 420 // 2, 580 // 2)))
n.append(Conv2d(feature_map_multiplier=4))
n.append(Relu())
n.append(UNet())
n.append(Conv2d(output_feature=1))
n.batchSize = 32
n.costFunction = cost.ImageDice
n.inputOutputType = (
T.tensor4(),
T.tensor4(),
)
n.build()
trX, trY, teX = l.load_kaggle_ultrasound()
trX = block_reduce(trX, block_size=(1, 1, 2, 2), func=np.mean)
trY = block_reduce(trY, block_size=(1, 1, 2, 2), func=np.mean)
teX = block_reduce(teX, block_size=(1, 1, 2, 2), func=np.mean)
trX = trX[:] / 255.0
trY = trY[:] / 255.0
teX = teX[:] / 255.0
for i in range(5000):
print(i)
n.train(trX, trX[:, :, :208, :288])
def test_generative():
import mlbase.cost as cost
import mlbase.layers.activation as act
import h5py
network = N.Network()
network.debug = True
network.setInput(N.RawInput((1, 28, 28)))
network.append(N.Conv2d(feature_map_multiplier=32))
network.append(act.Relu())
network.append(N.Pooling())
network.append(N.Conv2d(feature_map_multiplier=2))
network.append(act.Relu())
network.append(N.Pooling())
network.append(UpConv2d(feature_map_multiplier=2))
network.append(act.Relu())
network.append(UpConv2d(feature_map_multiplier=32))
network.append(act.Relu())
#network.append(N.Flatten())
#network.append(N.FullConn(input_feature=1152, output_feature=1152*2))
#network.append(N.Relu())
#network.append(N.FullConn(input_feature=1152*2, output_feature=10))
#network.append(N.SoftMax())
network.costFunction = cost.ImageSSE
network.inputOutputType = (
T.tensor4(),
T.tensor4(),
)
network.build()
f = h5py.File('/hdd/home/yueguan/workspace/data/mnist/mnist.hdf5', 'r')
trX = f['x_train'][:, :].reshape(-1, 1, 28, 28)
teX = f['x_test'][:, :].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
#network.train(trX, trY)
#print(1 - np.mean(np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
network.train(trX, trX)
print(
np.sum(
(teX - network.predict(teX)) * (teX - network.predict(teX))))
def test_build():
n = N.Network()
n.setInput(RawInput((1, 28, 28)))
n.append(Flatten())
n.append(FullConn(feature_map_multiplier=2))
n.append(Elu())
n.append(FullConn(output_feature=10))
n.append(output.SoftMax())
n.build()
assert n.learner is not None
assert n.predicter is not None
def test_mlp():
n = N.Network()
n.setInput(RawInput((1, 28, 28)))
n.append(Flatten())
n.append(FullConn(feature_map_multiplier=2))
n.append(Elu())
n.append(FullConn(output_feature=10))
n.append(output.SoftMax())
n.build()
trX, trY, teX, teY = l.load_mnist()
for i in range(100):
print(i)
n.train(trX, trY)
print(1 - np.mean(np.argmax(teY, axis=1) == np.argmax(n.predict(teX), axis=1)))
def test_connectLayer():
n = N.Network()
li = RawInput((1, 28, 28))
n.setInput(li)
lc1 = Conv2d(feature_map_multiplier=32)
la1 = Relu()
lp1 = Pooling()
n.connect(li, lc1)
n.connect(lc1, la1)
n.connect(la1, lp1)
g = n.nextLayer()
assert next(g) == li
assert next(g) == lc1
assert next(g) == la1
assert next(g) == lp1
with pytest.raises(Exception) as e:
next(g)
def test_nextLayerSeq():
n = N.Network()
n.setInput(RawInput((1, 28, 28)))
n.append(Flatten())
n.append(FullConn(feature_map_multiplier=2))
n.append(Elu())
n.append(FullConn(output_feature=10))
n.append(output.SoftMax())
g = n.nextLayer()
assert issubclass(type(next(g)), RawInput)
assert issubclass(type(next(g)), Flatten)
assert issubclass(type(next(g)), FullConn)
assert issubclass(type(next(g)), Elu)
assert issubclass(type(next(g)), FullConn)
assert issubclass(type(next(g)), output.SoftMax)
with pytest.raises(Exception) as e:
next(g)
def test_buildForwardSize():
n = N.Network()
inputLayer = RawInput((1, 28, 28))
n.setInput(inputLayer)
flatten = inputLayer.followedBy(Flatten())
full1 = flatten.followedBy(FullConn(feature_map_multiplier=2))
full2 = flatten.followedBy(FullConn(feature_map_multiplier=2))
concat = Concat().follow(full1, full2)
full3 = concat.followedBy(FullConn(feature_map_multiplier=2))
n.buildForwardSize()
for l in n.nextLayer():
if l == full1:
assert l.w.get_value().shape == (784, 1568)
elif l == full2:
assert l.w.get_value().shape == (784, 1568)
elif l == full3:
assert l.w.get_value().shape == (3136, 6272)
def test_binaryinput():
network = N.Network()
network.debug = True
network.setInput(RawInput((1, 28, 28)))
network.append(
Conv2d(filter_size=(3, 3), input_feature=1, output_feature=32))
network.append(Relu())
network.append(Pooling((2, 2)))
network.append(Binarize())
network.append(
Conv2d(filter_size=(3, 3), input_feature=32, output_feature=64))
network.append(Relu())
network.append(Pooling((2, 2)))
network.append(Binarize())
network.append(
Conv2d(filter_size=(3, 3), input_feature=64, output_feature=128))
network.append(Relu())
network.append(Pooling((2, 2)))
network.append(Flatten())
network.append(FullConn(input_feature=1152, output_feature=1152 * 2))
network.append(Relu())
network.append(FullConn(input_feature=1152 * 2, output_feature=10))
network.append(SoftMax())
network.build()
f = h5py.File('/hdd/home/yueguan/workspace/data/mnist/mnist.hdf5', 'r')
trX = f['x_train'][:, :].reshape(-1, 1, 28, 28)
teX = f['x_test'][:, :].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(
np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def test_train():
n = N.Network()
trainX = np.random.randint(2, size=(2000, 2))
trainY = (trainX.sum(axis=1, keepdims=True) % 2)
n.setInput(RawInput((2, )))
n.append(FullConn(input_feature=2, output_feature=2))
n.append(Elu())
n.append(FullConn(input_feature=2, output_feature=1))
n.costFunc = cost.ImageSSE
n.X = T.matrix()
n.build()
errorRateOld = np.mean((n.predict(trainX) - trainY)**2)
for i in range(5):
n.train(trainX, trainY)
errorRateNew = np.mean((n.predict(trainX) - trainY)**2)
assert errorRateNew < errorRateOld
def test():
import mlbase.network as N
import h5py
network = N.Network()
network.debug = True
network.setInput(N.RawInput((1, 28, 28)))
network.append(N.Conv2d(feature_map_multiplier=32))
network.append(ResLayer())
network.append(ResLayer())
network.append(ResLayer())
network.append(ResLayer(increase_dim=True))
network.append(ResLayer())
network.append(ResLayer())
network.append(ResLayer())
network.append(ResLayer(increase_dim=True))
network.append(ResLayer())
network.append(ResLayer())
network.append(ResLayer())
network.append(N.GlobalPooling())
network.append(N.FullConn(input_feature=128, output_feature=10))
network.append(N.SoftMax())
network.build()
f = h5py.File('/hdd/home/yueguan/workspace/data/mnist/mnist.hdf5', 'r')
trX = f['x_train'][:, :].reshape(-1, 1, 28, 28)
teX = f['x_test'][:, :].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(
np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def testbn():
network = N.Network()
network.debug = True
network.setSaveInterval(10)
network.setInput(RawInput((1, 28,28)))
network.append(conv.Conv2d(filter_size=(3,3), input_feature=1, output_feature=32))
network.append(N.BatchNormalization())
network.append(act.Relu())
network.append(pooling.Pooling((2,2)))
network.append(conv.Conv2d(filter_size=(3,3), input_feature=32, output_feature=64))
network.append(N.BatchNormalization())
network.append(act.Relu())
network.append(pooling.Pooling((2,2)))
network.append(conv.Conv2d(filter_size=(3,3), input_feature=64, output_feature=128))
network.append(N.BatchNormalization())
network.append(act.Relu())
network.append(pooling.Pooling((2,2)))
network.append(reshape.Flatten())
network.append(fullconn.FullConn(input_feature=1152, output_feature=1152*2))
network.append(act.Relu())
network.append(fullconn.FullConn(input_feature=1152*2, output_feature=10))
network.append(output.SoftMax())
network.build()
f = h5py.File('/home/rain/workspace/data/mnist.hdf5', 'r')
trX = f['x_train'][:,:].reshape(-1, 1, 28, 28)
teX = f['x_test'][:,:].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def test_networkSnapshot(tmpdir):
n = N.Network()
n.modelSavePath = str(tmpdir.mkdir("snapshot"))
n.modelPrefix = "test_snapshot"
time1 = datetime.datetime.strptime("2017-07-06_08-00-00",
'%Y-%m-%d_%H-%M-%S')
time2 = datetime.datetime.strptime("2017-07-06_09-00-00",
'%Y-%m-%d_%H-%M-%S')
fn1 = n.getSaveModelName(dateTime=time1)
fn2 = n.getSaveModelName(dateTime=time2)
open(fn1, 'a').close()
open(fn2, 'a').close()
n.updateLatestLink()
linkFileName = n.getLastLinkName()
assert os.path.realpath(linkFileName) == fn2
def test_nextLayerDiamond():
n = N.Network()
inputLayer = RawInput((1, 28, 28))
n.setInput(inputLayer)
flatten = inputLayer.followedBy(Flatten())
full1 = flatten.followedBy(FullConn(feature_map_multiplier=2))
full2 = flatten.followedBy(FullConn(feature_map_multiplier=2))
concat = Concat().follow(full1, full2)
full3 = concat.followedBy(FullConn(feature_map_multiplier=2))
g = n.nextLayer()
assert next(g) == inputLayer
assert next(g) == flatten
assert next(g) == full2
assert next(g) == full1
assert next(g) == concat
assert next(g) == full3
with pytest.raises(Exception) as e:
next(g)
def test_properties():
n = N.Network()
va = n.modelPrefix
vb = 'test'
n.modelPrefix = vb
assert n.modelPrefix != va
assert n.modelPrefix == vb
va = n.batchSize
vb = 39
n.batchSize = vb
assert n.batchSize != va
assert n.batchSize == vb
va = n.saveInterval
vb = 939
n.saveInterval = vb
assert n.saveInterval != va
assert n.saveInterval == vb
va = n.costFunction
vb = cost.CostFunc
n.costFunction = vb
assert n.costFunction != va
assert n.costFunction == vb
va = n.inputOutputType
vb = (T.dscalar(), T.dscalar())
n.inputOutputType = vb
assert all([v1.type != v2.type for v1, v2 in zip(n.inputOutputType, va)])
assert all([v1.type == v2.type for v1, v2 in zip(n.inputOutputType, vb)])
va = n.learningRate
vb = 99
n.learningRate = vb
assert n.learningRate != va
assert n.learningRate == vb
def test_globalpooling():
network = N.Network()
network.debug = True
network.setInput(RawInput((1, 28, 28)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=32))
network.append(bn.BatchNormalization())
network.append(act.Relu())
network.append(polling.Pooling((2, 2)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=2))
network.append(bn.BatchNormalization())
network.append(act.Relu())
network.append(pooling.Pooling((2, 2)))
network.append(conv.Conv2d(filter_size=(3, 3), feature_map_multiplier=2))
network.append(bn.BatchNormalization())
network.append(act.Relu())
network.append(pooling.GlobalPooling())
network.append(fullconn.FullConn(input_feature=128, output_feature=10))
network.append(output.SoftMax())
network.build()
f = h5py.File('/hdd/home/yueguan/workspace/data/mnist/mnist.hdf5', 'r')
trX = f['x_train'][:, :].reshape(-1, 1, 28, 28)
teX = f['x_test'][:, :].reshape(-1, 1, 28, 28)
trY = np.zeros((f['t_train'].shape[0], 10))
trY[np.arange(len(f['t_train'])), f['t_train']] = 1
teY = np.zeros((f['t_test'].shape[0], 10))
teY[np.arange(len(f['t_test'])), f['t_test']] = 1
for i in range(5000):
print(i)
network.train(trX, trY)
print(1 - np.mean(
np.argmax(teY, axis=1) == np.argmax(network.predict(teX), axis=1)))
def testload():
n = N.Network()
n.loadFromFile()
n.saveToFile('testmodel')
def convert(def_path, caffemodel_path, output_path, phase):
# read from .prototxt file to collect layers.
params = caffe.proto.caffe_pb2.NetParameter()
with open(def_path, 'r') as def_file:
text_format.Merge(def_file.read(), params)
layerName2InstanceMap = {} # dict of str:layer
layerName2Bottom = {} # dict of str:list
inplaceOpMap = {} # dict of str:str
inputLayer = None
for layer in params.layer:
lname = layer.name
ltype = layer.type
ltop = layer.top
lbottom = layer.bottom
if len(ltop) > 0 and len(lbottom) > 0 and ltop[0] == lbottom[0]:
inplaceOpMap[lbottom[0]] = lname
if ltype == 'Input':
nl = L.RawInput((layer.input_param.shape[0].dim[1],
layer.input_param.shape[0].dim[2],
layer.input_param.shape[0].dim[3]))
nl.name = lname
layerName2InstanceMap[layer.name] = nl
inputLayer = nl
elif ltype == 'Convolution':
name = layer.name
bottom = layer.bottom
output_feature_map = layer.convolution_param.num_output
kernel_size = layer.convolution_param.kernel_size[0]
stride = (1, 1)
if len(layer.convolution_param.stride) > 0:
stride = layer.convolution_param.stride[0]
stride = (stride, stride)
nl = L.Conv2d(filter_size=(kernel_size, kernel_size),
output_feature=output_feature_map,
subsample=stride)
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif ltype == 'ReLU':
nl = L.Relu()
nl.name = lname
name = layer.name
bottom = layer.bottom
top = layer.top
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif layer.type == 'Pooling':
name = layer.name
# 0: max, 1: average, 2: stochastic
poolingMethod = layer.pooling_param.pool
if poolingMethod == 0:
poolingMethod = 'max'
elif poolingMethod == 1:
poolingMethod = 'avg'
kernel_size = layer.pooling_param.kernel_size
stride = layer.pooling_param.stride
pad = layer.pooling_param.pad
nl = L.Pooling(dsize=(kernel_size, kernel_size),
stride=(stride, stride),
pad=(pad, pad),
mode=poolingMethod)
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif layer.type == 'LRN':
name = layer.name
local_size = layer.lrn_param.local_size
alpha = layer.lrn_param.alpha
beta = layer.lrn_param.beta
nl = L.LRN(local_size=local_size, alpha=alpha, beta=beta)
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif layer.type == 'Concat':
name = layer.name
nl = L.Concat()
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif layer.type == 'Dropout':
name = layer.name
ratio = layer.dropout_param.dropout_ratio
nl = L.Dropout(p=ratio)
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
elif layer.type == 'InnerProduct':
name = layer.name
output_feature = layer.inner_product_param.num_output
nl = L.FullConn(output_feature=output_feature)
nl.name = lname
layerName2InstanceMap[name] = nl
if not isinstance(layerName2InstanceMap[layer.bottom[0]],
L.Flatten):
print('Insert flatten layer before full connection')
fl = L.Flatten()
fl.name = name + 'pre_flatten'
layerName2InstanceMap[fl.name] = fl
layerName2Bottom[fl.name] = layer.bottom
layerName2Bottom[name] = (fl.name, )
else:
layerName2Bottom[name] = layer.bottom
elif layer.type == 'Softmax':
name = layer.name
nl = L.SoftMax()
nl.name = lname
layerName2InstanceMap[name] = nl
layerName2Bottom[name] = layer.bottom
else:
print(layer.type)
raise NotImplementedError('unknown caffe layer.')
print(inplaceOpMap)
# create the network
n = N.Network()
for name in layerName2InstanceMap.keys():
if name in layerName2Bottom:
for bottomLayer in layerName2Bottom[name]:
if bottomLayer in inplaceOpMap.keys(
) and inplaceOpMap[bottomLayer] != name:
n.connect(layerName2InstanceMap[inplaceOpMap[bottomLayer]],
layerName2InstanceMap[name],
reload=True)
else:
n.connect(layerName2InstanceMap[bottomLayer],
layerName2InstanceMap[name],
reload=True)
n.setInput(inputLayer, reload=True)
n.buildForwardSize()
# read .caffemodel file to load real parameters.
net_param = caffe_pb2.NetParameter()
with open(caffemodel_path, 'rb') as f:
net_param.ParseFromString(f.read())
for layer in net_param.layers:
lname = layer.name # str
ltype = layer.type # int, the mapping is defined in caffe/src/caffe/proto/caffe.proto
bottom = layer.bottom # RepeatedScalarContainer
top = layer.top # RepeatedScalarContainer
print("{}, {}".format(lname, ltype))
if lname in layerName2InstanceMap.keys():
if ltype == 4: # convolution
w = np.array(layer.blobs[0].data).reshape(
(layer.blobs[0].num, layer.blobs[0].channels,
layer.blobs[0].height, layer.blobs[0].width), )
bias = np.array(layer.blobs[1].data).reshape(
(layer.blobs[1].width), )
print(w.shape)
if w.shape != layerName2InstanceMap[lname].w.get_value().shape:
print(w.shape)
print(layerName2InstanceMap[lname].w.get_value().shape)
raise Exception('Error, w shape do not match.')
if bias.shape != layerName2InstanceMap[lname].b.get_value(
).shape:
print(bias.shape)
print(layerName2InstanceMap[lname].b.get_value().shape)
raise Exception('Error, b shape do not match.')
layerName2InstanceMap[lname].w = theano.shared(floatX(w),
borrow=True)
layerName2InstanceMap[lname].b = theano.shared(floatX(bias),
borrow=True)
elif ltype == 5: # data
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 18: # relu
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 17: # pooling
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 15: # lrn
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 3: # concat
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 6: # dropout
print('seen name: {}, {}'.format(lname, ltype))
elif ltype == 14: # fullconn
print('seen name: {}, {}'.format(lname, ltype))
w = np.array(layer.blobs[0].data).reshape(
(layer.blobs[0].width, layer.blobs[0].height), )
bias = np.array(layer.blobs[1].data).reshape(
(layer.blobs[1].width), )
print("heh:{}".format(lname))
print(layerName2InstanceMap[lname])
print(layerName2InstanceMap[lname].w)
if w.shape != layerName2InstanceMap[lname].w.get_value().shape:
print(w.shape)
print(layerName2InstanceMap[lname].w.get_value().shape)
raise Exception('Error, w shape do not match.')
if bias.shape != layerName2InstanceMap[lname].b.get_value(
).shape:
print(bias.shape)
print(layerName2InstanceMap[lname].b.get_value().shape)
raise Exception('Error, b shape do not match.')
layerName2InstanceMap[lname].w = theano.shared(floatX(w),
borrow=True)
layerName2InstanceMap[lname].b = theano.shared(floatX(bias),
borrow=True)
elif ltype == 21: # 21 for Softmax output, 20 for softmax
print('seen name: {}, {}'.format(lname, ltype))
else:
print('seen name: {}, unknown type: {}'.format(lname, ltype))
else:
if len(layer.blobs) > 0:
#raise NotImplementedError('unseen layer with blobs: {}'.format(lname))
print('error, unseen layer with blobs: {}, {}'.format(
lname, ltype))
else:
#print('warning, unseen name: {}, {}'.format(lname, ltype))
pass
# finally build the network.
n.build(reload=True)
return n
