#coding:utf-8
#http://blog.csdn.net/zhuiqiuk/article/details/53376283
#http://blog.csdn.net/gan_player/article/details/77586489
# from __future__ import absolute_import, unicode_literals
# from tensorflow.examples.tutorials.mnist import input_data
# import tensorflow as tf
# import shutil
# import os.path
# from tensorflow.python.framework import graph_util
#import mxnet as mx
# import numpy as np
# import random
# import cv2
# from time import sleep
# from easydict import EasyDict as edict
# import logging
# import pdb
# import math
# import re
import tensorflow as tf
import numpy as np
#import getmxnetmodel
# def load_checkpoint():
# """
# Load model checkpoint from file.
# :param prefix: Prefix of model name.
# :param epoch: Epoch number of model we would like to load.
# :return: (arg_params, aux_params)
# arg_params : dict of str to NDArray
# Model parameter, dict of name to NDArray of net's weights.
# aux_params : dict of str to NDArray
# Model parameter, dict of name to NDArray of net's auxiliary states.
# """
# save_dict = mx.nd.load('model-0000.params')
# arg_params = {}
# aux_params = {}
# for k, v in save_dict.items():
# tp, name = k.split(':', 1)
# if tp == 'arg':
# arg_params[name] = v
# if tp == 'aux':
# aux_params[name] = v
# return arg_params, aux_params
# def convert_context(params, ctx):
# """
# :param params: dict of str to NDArray
# :param ctx: the context to convert to
# :return: dict of str of NDArray with context ctx
# """
# new_params = dict()
# for k, v in params.items():
# new_params[k] = v.as_in_context(ctx)
# #print new_params[0]
# return new_params
# def load_param(convert=False, ctx=None):
# """
# wrapper for load checkpoint
# :param prefix: Prefix of model name.
# :param epoch: Epoch number of model we would like to load.
# :param convert: reference model should be converted to GPU NDArray first
# :param ctx: if convert then ctx must be designated.
# :return: (arg_params, aux_params)
# """
# arg_params, aux_params = load_checkpoint()
# if convert:
# if ctx is None:
# ctx = mx.cpu()
# arg_params = convert_context(arg_params, ctx)
# aux_params = convert_context(aux_params, ctx)
# return arg_params, aux_params
def conv_weight_variable(params, name):
#def conv_weight_variable():
#conv_weight = params[0][name + "_weight"].asnumpy()
#tf height * width * in_channels * output_channels
#mxnet output_channels * in_channels * height * width
height = 5
width = 5
inchannel = 1
outchannel = 2
#conv0 (64, 112, 112) kernel (3, 3) stride (1, 1) pad (1, 1)
wkernel = 3
stride = 1
pad = 1
dilate = 1
conv_weight = np.arange(wkernel * wkernel * inchannel * outchannel).reshape((outchannel,inchannel,wkernel,wkernel))
conv_weight =conv_weight.transpose(3,2,1,0)
print(conv_weight.shape)
print('input:',conv_weight)
conv_weight = tf.Variable(conv_weight, dtype=np.float32, name = "weight")
return conv_weight
# def bias_variable(shape, params):
# initial = tf.constant(0.1, shape=shape)
# return tf.Variable(initial)
# def bn_variable(params, name):
# bn_beta = params[0][name + "_beta"].asnumpy()
# bn_gamma = params[0][name + "_gamma"].asnumpy()
# bn_moving_mean = params[1][name + "_moving_mean"].asnumpy()
# bn_moving_var = params[1][name + "_moving_var"].asnumpy()
# mean = tf.Variable(bn_moving_mean, dtype=np.float32, name = name + "_moving_mean")
# variance = tf.Variable(bn_moving_var, dtype=np.float32, name = name + "_moving_var")
# offset = tf.Variable(bn_beta, dtype=np.float32, name = name + "_beta")
# scale = tf.Variable(bn_gamma, dtype=np.float32, name = name + "_gamma")
# return mean, variance, offset, scale
# def fc_variable(params, name):
# fc_weight = params[0][name + "_weight"].asnumpy()
# fc_weight = fc_weight.transpose(1,0)
# fc_bias = params[0][name + "_bias"].asnumpy()
# fc_weight = tf.Variable(fc_weight, dtype=np.float32, name = name + "_weight")
# fc_bias = tf.Variable(fc_bias, dtype=np.float32, name = name + "_bias")
# return fc_weight, fc_bias
# def act_variable(params, name):
# relu_gamma = params[0][name + "_gamma"].asnumpy()
# print(relu_gamma)
# #tf_gamma_data = tf.Variable(relu_gamma, dtype=np.float32)
# tf_gamma_data = tf.Variable(relu_gamma, dtype=np.float32, name = name + "_gamma")
# return tf_gamma_data
# def conv2d(input, filter, stride, padding, name):
# kernel = filter.get_shape()[0]
# if padding == 0:
# conv = tf.nn.conv2d(input, filter, strides=[1, stride, stride, 1], padding='VALID')
# elif stride == 2:
# kernel_size = kernel
# kernel_size_effective = kernel_size
# pad_total = kernel_size_effective - 1
# pad_beg = pad_total // 2
# pad_end = pad_total - pad_beg
# #print(pad_beg, pad_end)
# input_PadLayer = tf.pad(input, [[0, 0], [pad_beg, pad_end], [pad_beg, pad_end], [0, 0]], name=name)
# conv = tf.nn.conv2d(input_PadLayer, filter, strides=[1, stride, stride, 1], padding='VALID')
# else:
# conv = tf.nn.conv2d(input, filter, strides=[1, stride, stride, 1], padding='SAME')
# return conv
# def BatchNorm(input, mean, variance, offset, scale, variance_epsilon, name):
# # x = tf_prelu
# # mean = tf.Variable(bn_moving_mean, dtype=np.float32)
# # variance = tf.Variable(bn_moving_var, dtype=np.float32)
# # offset = tf.Variable(bn_beta, dtype=np.float32)
# # scale = tf.Variable(bn_gamma, dtype=np.float32)
# # variance_epsilon = 2e-5
# tf_bn = tf.nn.batch_normalization(input, mean,variance,offset,scale,variance_epsilon,name=name)
# return tf_bn
# def Act(data, act_type, tf_gamma_data, name):
# if act_type=='prelu':
# actdata = tf.nn.leaky_relu(data, alpha=tf_gamma_data,name=name)
# else:
# #acydaya = tf.nn.relu(data = data, act_type=act_type, name=name)
# actdata = data
# return actdata
# def FullyConnected(input, fc_weight, fc_bias, name):
# fc = tf.matmul(input, fc_weight) + fc_bias
# return fc
# def max_pool_2x2(x):
# return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
# strides=[1, 2, 2, 1], padding='SAME')
# def inference(input_image, params):
# x_image = tf.reshape(input_image, [1, 5, 5, 1])
# stride = 1; pad = 1; name = "conv0"
# W_conv0 = conv_weight_variable(params, name)
# body = conv2d(x_image, W_conv0, stride, pad, name)
# # variance_epsilon = 2e-5;name = "bn0"
# # mean, variance, offset, scale = bn_variable(params, name)
# # body = BatchNorm(body, mean, variance, offset, scale, variance_epsilon, name)
# # act_type = 'prelu'; name = "relu0"
# # tf_gamma_data = act_variable(params, name)
# # body = Act(body, act_type, tf_gamma_data, name)
# # name = "fc0"
# # weight_fc, bias_fc = fc_variable(params, name)
# # body = tf.reshape(body, [-1, body.get_shape()[1] * body.get_shape()[2] * body.get_shape()[3]])
# # body = FullyConnected(body, weight_fc, bias_fc, name)
# return body
# def train(export_dir):
# mnist = input_data.read_data_sets("datasets", one_hot=True)
# g = tf.Graph()
# with g.as_default():
# x = tf.placeholder("float", shape=[None, 784])
# y_ = tf.placeholder("float", shape=[None, 10])
# keep_prob = tf.placeholder("float")
# logits = inference(x, keep_prob)
# y_conv = tf.nn.softmax(logits)
# cross_entropy = -tf.reduce_sum(y_ * tf.log(y_conv))
# train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
# accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# sess = tf.Session()
# sess.run(tf.initialize_all_variables())
# step = 200
# batch_size = 50
# for i in range(step+1):
# batch = mnist.train.next_batch(batch_size)
# if i % 10 == 0:
# train_accuracy = accuracy.eval(
# {x: batch[0], y_: batch[1], keep_prob: 1.0}, sess)
# print "step %d, training accuracy %g" % (i, train_accuracy)
# train_step.run(
# {x: batch[0], y_: batch[1], keep_prob: 0.5}, sess)
# print "test accuracy %g" % accuracy.eval(
# {x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}, sess)
# saver = tf.train.Saver()
# checkpoint_file = os.path.join(export_dir, 'model.ckpt')
# saver.save(sess, checkpoint_file, global_step=step)
# checkpoint_file = os.path.join(export_dir, 'model.ckpt')
# def export_pb_model(model_name):
# graph = tf.Graph()
# with graph.as_default():
# input_image = tf.placeholder("float", shape=[None,28*28], name='inputdata')
# keep_prob = tf.placeholder("float", name = 'keep_probdata')
# logits = inference(input_image, keep_prob)
# y_conv = tf.nn.softmax(logits,name='outputdata')
# restore_saver = tf.train.Saver()
# with tf.Session(graph=graph) as sess:
# sess.run(tf.global_variables_initializer())
# latest_ckpt = tf.train.latest_checkpoint('log')
# restore_saver.restore(sess, latest_ckpt)
# output_graph_def = tf.graph_util.convert_variables_to_constants(
# sess, graph.as_graph_def(), ['outputdata'])
# # tf.train.write_graph(output_graph_def, 'log', model_name, as_text=False)
# with tf.gfile.GFile(model_name, "wb") as f:
# f.write(output_graph_def.SerializeToString())
# def test_pb_model(model_name):
# mnist = input_data.read_data_sets("datasets", one_hot=True)
# with tf.Graph().as_default():
# output_graph_def = tf.GraphDef()
# output_graph_path = model_name
# # sess.graph.add_to_collection("input", mnist.test.images)
# with open(output_graph_path, "rb") as f:
# output_graph_def.ParseFromString(f.read())
# tf.import_graph_def(output_graph_def, name="")
# with tf.Session() as sess:
# tf.initialize_all_variables().run()
# input_x = sess.graph.get_tensor_by_name("inputdata:0")
# output = sess.graph.get_tensor_by_name("outputdata:0")
# keep_prob = sess.graph.get_tensor_by_name("keep_probdata:0")
# y_conv_2 = sess.run(output,{input_x:mnist.test.images, keep_prob: 1.0})
# print( "y_conv_2", y_conv_2)
# # Test trained model
# #y__2 = tf.placeholder("float", [None, 10])
# y__2 = mnist.test.labels
# correct_prediction_2 = tf.equal(tf.argmax(y_conv_2, 1), tf.argmax(y__2, 1))
# print ("correct_prediction_2", correct_prediction_2 )
# accuracy_2 = tf.reduce_mean(tf.cast(correct_prediction_2, "float"))
# print ("accuracy_2", accuracy_2)
# print ("check accuracy %g" % accuracy_2.eval())
# def showmodel():
# result = load_param()
# #pdb.set_trace()
# print('result is', result)
# #print result
# for dic in result:
# #dic = sorted(dic.keys())
# for key in sorted(dic.keys()):
# print(key, dic[key].shape)
# #print(key,dic[key])
# print('one of results conv0_weight is:')
# conv0_weight = result[0]['conv0_weight'].asnumpy()
# print('name:',conv0_weight.shape)
# print('value:',result[0]['conv0_weight'].asnumpy())
# def get_netpoint_params(params, name):
# # (u'bn0_beta', (2L,))
# # (u'bn0_gamma', (2L,))
# # (u'conv0_weight', (2L, 1L, 3L, 3L))
# # (u'fc2_bias', (10L,))
# # (u'fc2_weight', (10L, 1568L))
# # (u'relu0_gamma', (2L,))
# # (u'bn0_moving_mean', (2L,))
# # (u'bn0_moving_var3 (2L,))
# name_split = name.strip().split('_')
# train_variable = ['conv','bn','relu','fc']
# for var in train_variable:
# index = var.find('a',0)
# if index != -1:
# continue
# if index == -1:
# print("netpoint name is error")
# else:
# if index == 0:
# conv_weight = params[0][name + "_weight"].asnumpy()
# elif index == 1:
# bn_beta = params[0][name + "_beta"].asnumpy()
# bn_gamma = params[0][name + "_gamma"].asnumpy()
# bn__moving_mean = params[0][name + "__moving_mean"].asnumpy()
# bn_moving_var = params[0][name + "_moving_var"].asnumpy()
# elif index == 2:
# relu_gamma = params[0][name + "_gamma"].asnumpy()
# elif index == 3:
# fc_weight = params[0][name + "_weight"].asnumpy()
# fc_bias = params[0][name + "_bias"].asnumpy()
# def softmax(x):
# """
# Compute the softmax function for each row of the input x.
# Arguments:
# x -- A N dimensional vector or M x N dimensional numpy matrix.
# Return:
# x -- You are allowed to modify x in-place
# """
# orig_shape = x.shape
# if len(x.shape) > 1:
# # Matrix
# exp_minmax = lambda x: np.exp(x - np.max(x))
# denom = lambda x: 1.0 / np.sum(x)
# x = np.apply_along_axis(exp_minmax,1,x)
# denominator = np.apply_along_axis(denom,1,x)
# if len(denominator.shape) == 1:
# denominator = denominator.reshape((denominator.shape[0],1))
# x = x * denominator
# else:
# # Vector
# x_max = np.max(x)
# x = x - x_max
# numerator = np.exp(x)
# denominator = 1.0 / np.sum(numerator)
# x = numerator.dot(denominator)
# assert x.shape == orig_shape
# return x
def eval():
#mxnet_params = load_param()
# label = 9
# img = cv2.imread('./mnist_img/mnist_train_8.jpg',0)
# img = cv2.resize(img,(5,5))
# img = np.expand_dims(img, axis=0)
# img = np.expand_dims(img, axis=0)
# data = np.arange(5 * 5 * 1).reshape((1,1,5,5))
# data = data.transpose(0,3,2,1)
# input_image = tf.Variable(data, dtype=np.float32)
# print('img',img)
# #logdit = inference(input_image, mxnet_params)
# #x_image = tf.reshape(input_image, [1, 5, 5, 1])
# stride = 1; pad = 1; name = "conv0"
# W_conv0 = conv_weight_variable(mxnet_params, name)
# body = conv2d(input_image, W_conv0, stride, pad, name)
# init = tf.global_variables_initializer()
# with tf.Session() as sess:
# sess.run(init)
# fc = sess.run(body)
# print(fc)
# with tf.Graph().as_default():
# #with tf.Session() as sess:
# input_image = tf.placeholder("float", [1, 1, 28, 28])
# logdit = inference(input_image, mxnet_params)
# init = tf.global_variables_initializer()
# with tf.Session() as sess:
# sess.run(init)
# # gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.8)
# # sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
# sess.run(tf.initialize_all_variables())
# fc = sess.run(logdit,{input_image:img})
# print( "fc", fc)
# softmax_fc = softmax(fc)
# print(softmax_fc)
# max_index = np.argmax(softmax_fc, axis=1)
# print("label ", label)
# print("predit ", max_index)
# print(max_index == label)
height = 5
width = 5
inchannel = 1
outchannel = 2
#conv0 (64, 112, 112) kernel (3, 3) stride (1, 1) pad (1, 1)
wkernel = 3
stride = 1
pad = 1
dilate = 1
# w = np.arange(wkernel * wkernel * inchannel * outchannel).reshape((outchannel,inchannel,wkernel,wkernel))
# b = np.array([0])
mxnet_params = 1
w = conv_weight_variable(mxnet_params,"conv0")
data = np.arange(height * width * inchannel).reshape((1,inchannel,height,width))
print('input:',data)
print('weight:',w)
data = data.transpose(0,3,2,1)
#w = w.transpose(3,2,1,0)
# print('input:',data)
# print('inputshape:',data.shape)
# print('weight:',w)
# print('weight:',w.shape)
input = tf.Variable(data, dtype=np.float32)
#input_reshape = tf.reshape(input, [1,inchannel,height,width])
filter = tf.Variable(w, dtype=np.float32)
conv = tf.nn.conv2d(input, filter, strides=[1, stride, stride, 1], padding='SAME')
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
#print("input: \n", sess.run(input))
input_reshape = sess.run(input).transpose(0,3,2,1)
#print("input_reshape: \n", input_reshape)
#print("filter: \n", sess.run(filter))
filter_reshape = sess.run(filter).transpose(3,2,1,0)
#print("filter_reshape: \n", filter_reshape)
#print("conv ", sess.run(conv))
conv_reshape = sess.run(conv).transpose(0,3,2,1)
print("conv_reshape: \n", conv_reshape)
# tf_prelu_reshape = sess.run(tf_prelu).transpose(0,3,2,1)
# print("tf_prelu_reshape: \n", tf_prelu_reshape)
# tf_bn_reshape = sess.run(tf_bn).transpose(0,3,2,1)
# print("tf_bn_reshape: \n", tf_bn_reshape)
if __name__ == '__main__':
eval()
#showmodel()
#load mxnet model
#mxnet_params = load_param()
# import re
# print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配
# print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配
# info = 'abca'
# print info.find('a')##从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
# info = 'abca'
# print info.find('a',1)##从下标1开始，查找在字符串里第一个出现的子串：返回结果3
# info = 'abca'
# print info.find('333')##返回-1,查找不到返回-1
# export_dir = './log'
# if os.path.exists(export_dir):
# shutil.rmtree(export_dir)
#训练并保存模型ckpt
#train(export_dir)
#model_name = os.path.join(export_dir, 'mnist.pb')
# #ckpt模型转换为pb模型
# export_pb_model(model_name)
# #测试pb模型
# test_pb_model(model_name)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from scipy import misc
import sys
import os
import argparse
import tensorflow as tf
import numpy as np
import mxnet as mx
import random
import cv2
from time import sleep
from easydict import EasyDict as edict
import logging
import pdb
import math
def load_checkpoint():
"""
Load model checkpoint from file.
:param prefix: Prefix of model name.
:param epoch: Epoch number of model we would like to load.
:return: (arg_params, aux_params)
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
"""
save_dict = mx.nd.load('model-0000.params')
arg_params = {}
aux_params = {}
for k, v in save_dict.items():
tp, name = k.split(':', 1)
if tp == 'arg':
arg_params[name] = v
if tp == 'aux':
aux_params[name] = v
return arg_params, aux_params
def convert_context(params, ctx):
"""
:param params: dict of str to NDArray
:param ctx: the context to convert to
:return: dict of str of NDArray with context ctx
"""
new_params = dict()
for k, v in params.items():
new_params[k] = v.as_in_context(ctx)
#print new_params[0]
return new_params
def load_param(convert=False, ctx=None):
"""
wrapper for load checkpoint
:param prefix: Prefix of model name.
:param epoch: Epoch number of model we would like to load.
:param convert: reference model should be converted to GPU NDArray first
:param ctx: if convert then ctx must be designated.
:return: (arg_params, aux_params)
"""
arg_params, aux_params = load_checkpoint()
if convert:
if ctx is None:
ctx = mx.cpu()
arg_params = convert_context(arg_params, ctx)
aux_params = convert_context(aux_params, ctx)
return arg_params, aux_params
def srctrain():
logging.getLogger().setLevel(logging.DEBUG)
batch_size = 100
mnist = mx.test_utils.get_mnist()
train_iter = mx.io.NDArrayIter(mnist['train_data'], mnist['train_label'], batch_size, shuffle=True)
val_iter = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size)
data = mx.sym.var('data')
# first conv layer
conv1= mx.sym.Convolution(data=data, kernel=(5,5), num_filter=20)
tanh1= mx.sym.Activation(data=conv1, act_type="tanh")
pool1= mx.sym.Pooling(data=tanh1, pool_type="max", kernel=(2,2), stride=(2,2))
# second conv layer
conv2= mx.sym.Convolution(data=pool1, kernel=(5,5), num_filter=50)
tanh2= mx.sym.Activation(data=conv2, act_type="tanh")
pool2= mx.sym.Pooling(data=tanh2, pool_type="max", kernel=(2,2), stride=(2,2))
# first fullc layer
flatten= mx.sym.Flatten(data=pool2)
fc1= mx.symbol.FullyConnected(data=flatten, num_hidden=500)
tanh3= mx.sym.Activation(data=fc1, act_type="tanh")
# second fullc
fc2= mx.sym.FullyConnected(data=tanh3, num_hidden=10)
# softmax loss
lenet= mx.sym.SoftmaxOutput(data=fc2, name='softmax')
# create a trainable module on GPU 0
lenet_model = mx.mod.Module(
symbol=lenet,
context=mx.cpu())
# train with the same
lenet_model.fit(train_iter,
eval_data=val_iter,
optimizer='sgd',
optimizer_params={'learning_rate':0.1},
eval_metric='acc',
batch_end_callback = mx.callback.Speedometer(batch_size, 100),
num_epoch=2)
#save model
msave = 0
print('saving', msave)
arg, aux = lenet_model.get_params()
prefix = "./model"
mx.model.save_checkpoint(prefix, msave, lenet_model.symbol, arg, aux)
def Act(data, act_type, name):
if act_type=='prelu':
body = mx.sym.LeakyReLU(data = data, act_type='prelu', name = name)
else:
body = mx.symbol.Activation(data=data, act_type=act_type, name=name)
return body
global input_size
def out_dim(input = (3,112,112), num_filter = 64,
kernel = (3,3), stride = (1,1), pad = (1,1), dilate = (1,1), name="point", isconv=True):
if isconv==True:
if pad == None:
pad=(0,0)
channels = input[0]
height = input[1]
width = input[2]
x = height
p = pad[0]
s = stride[0]
d = dilate[0]
k = kernel[0]
output_height = (int)(math.floor((x + 2 * p - d * (k - 1) - 1) / s) + 1)
y = width
p = pad[1]
s = stride[1]
d = dilate[1]
k = kernel[1]
output_width = (int)(math.floor((x + 2 * p - d * (k - 1) - 1) / s) + 1)
output = (num_filter, output_height, output_width)
else:
output = input
print(name, output, "kernel",kernel, "stride", stride, "pad", pad)
return output
def Conv(**kwargs):
#name = kwargs.get('name')
#_weight = mx.symbol.Variable(name+'_weight')
#_bias = mx.symbol.Variable(name+'_bias', lr_mult=2.0, wd_mult=0.0)
#body = mx.sym.Convolution(weight = _weight, bias = _bias, **kwargs)
name = kwargs.get('name')
num_filter = kwargs.get('num_filter')
kernel = kwargs.get('kernel')
stride = kwargs.get('stride')
pad = kwargs.get('pad')
global input_size
input_size = out_dim(input = input_size, num_filter = num_filter,
kernel=kernel, stride=stride, pad=pad, dilate = (1,1), name=name, isconv=True)
body = mx.sym.Convolution(**kwargs)
return body
def resnettrain():
logging.getLogger().setLevel(logging.DEBUG)
batch_size = 100
bn_mom = 0.9
act_type = 'prelu'
global input_size
input_size = (1,28,28)
mnist = mx.test_utils.get_mnist()
train_iter = mx.io.NDArrayIter(mnist['train_data'], mnist['train_label'], batch_size, shuffle=True)
val_iter = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size)
#label = mx.sym.var('softmax_label')
data = mx.sym.var('data')
# first conv layer
body = Conv(data=data, num_filter=2, kernel=(3,3), stride=(1,1), pad=(1, 1),
no_bias=True, name="conv0")
body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn0')
print('bn0', input_size)
body = Act(data=body, act_type=act_type, name='relu0')
print('relu0', input_size)
# # second conv layer
# body = Conv(data=body, num_filter=4, kernel=(3,3), stride=(2,2), pad=(1, 1),
# no_bias=True, name="conv1")
# body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn1')
# print('bn1', input_size)
# body = Act(data=body, act_type=act_type, name='relu1')
# print('relu1', input_size)
# # third conv layer
# body = Conv(data=body, num_filter=6, kernel=(1,1), stride=(2,2), pad=(0, 0),
# no_bias=True, name="conv2")
# body = mx.sym.BatchNorm(data=body, fix_gamma=False, eps=2e-5, momentum=bn_mom, name='bn2')
# print('bn2', input_size)
# body = Act(data=body, act_type=act_type, name='relu2')
# print('relu2', input_size)
# first fullc layer
#body= mx.sym.Flatten(data=body)
#body= mx.symbol.FullyConnected(data=body, num_hidden=20, name='fc1')
#body= mx.sym.Activation(data=body, act_type="tanh", name="Act1")
#body= Act(data=body, act_type=act_type, name='relu1')
# second fullc
body= mx.sym.FullyConnected(data=body, num_hidden=10, name='fc0')
#softmax loss
lenet= mx.sym.SoftmaxOutput(data=body, name='softmax')
# create a trainable module on GPU 0
lenet_model = mx.mod.Module(
symbol=lenet,
context=mx.cpu())
# train with the same
lenet_model.fit(train_iter,
eval_data=val_iter,
optimizer='sgd',
optimizer_params={'learning_rate':0.1},
eval_metric='acc',
batch_end_callback = mx.callback.Speedometer(batch_size, 100),
num_epoch=2)
#save model
msave = 0
print('saving', msave)
arg, aux = lenet_model.get_params()
prefix = "./model"
mx.model.save_checkpoint(prefix, msave, lenet_model.symbol, arg, aux)
def showmodel():
result = load_param()
#pdb.set_trace()
#rint('result is', result)
#print result
for dic in result:
#dic = sorted(dic.keys())
for key in sorted(dic.keys()):
print(key, dic[key].shape)
#print(key,dic[key])
print('one of results conv0_weight is:')
conv0_weight = result[0]['conv0_weight'].asnumpy()
print('name:',conv0_weight.shape)
print('value:',result[0]['conv0_weight'].asnumpy())
class MnistModel:
def __init__(self, args):
self.args = args
model = edict()
_vec = args.model.split(',')
assert len(_vec)==2
prefix = _vec[0]
epoch = int(_vec[1])
print('loading',prefix, epoch)
ctx = mx.gpu(args.gpu)
sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch)
all_layers = sym.get_internals()
sym = all_layers['fc0_output']
model = mx.mod.Module(symbol=sym, context=ctx, label_names = None)
image_size = (28,28)
#model.bind(data_shapes=[('data', (1, 1, image_size[0], image_size[1]))], label_shapes=[('softmax_label', (1,))])
model.bind(data_shapes=[('data', (1, 1, image_size[0], image_size[1]))])
model.set_params(arg_params, aux_params)
self.model = model
def get_feature(self, img):
#face_img is bgr image
#img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#aligned = np.transpose(img, (2,0,1))
aligned = img
#print(nimg.shape)
embedding = None
input_blob = np.expand_dims(aligned, axis=0)
data = mx.nd.array(input_blob)
#label = mx.nd.array((1,))
db = mx.io.DataBatch(data=(data,))
self.model.forward(db, is_train=False)
_embedding = self.model.get_outputs()[0].asnumpy()
#print(_embedding.shape)
embedding = _embedding
return embedding
def softmax(x):
"""
Compute the softmax function for each row of the input x.
Arguments:
x -- A N dimensional vector or M x N dimensional numpy matrix.
Return:
x -- You are allowed to modify x in-place
"""
orig_shape = x.shape
if len(x.shape) > 1:
# Matrix
exp_minmax = lambda x: np.exp(x - np.max(x))
denom = lambda x: 1.0 / np.sum(x)
x = np.apply_along_axis(exp_minmax,1,x)
denominator = np.apply_along_axis(denom,1,x)
if len(denominator.shape) == 1:
denominator = denominator.reshape((denominator.shape[0],1))
x = x * denominator
else:
# Vector
x_max = np.max(x)
x = x - x_max
numerator = np.exp(x)
denominator = 1.0 / np.sum(numerator)
x = numerator.dot(denominator)
assert x.shape == orig_shape
return x
def eval():
parser = argparse.ArgumentParser(description='mnist model test')
# general
parser.add_argument('--image-size', default='28,28', help='')
parser.add_argument('--model', default='./model,0', help='path to load model.')
parser.add_argument('--gpu', default=0, type=int, help='gpu id')
args = parser.parse_args()
model = MnistModel(args)
label = 9
img = cv2.imread('./mnist_img/mnist_train_8.jpg',0)
img = cv2.resize(img,(28,28))
img = np.expand_dims(img, axis=0)
f1 = model.get_feature(img)
print(f1.shape)
print(f1)
softmax_f1 = softmax(f1)
print(softmax_f1)
max_index = np.argmax(softmax_f1, axis=1)
print("label ", label)
print("predit ", max_index)
print(max_index == label)
def rgb2gray(rgb):
return np.dot(rgb[...,:3], [0.299, 0.587, 0.114])
if __name__ == '__main__':
#resnettrain()
showmodel()
#eval()
# a = np.array([[1,2,3,4]])
# print(a.shape)
# #a = np.array([[1,2,3,4],[1,2,3,4]])
# print(softmax(a))
# y_hat = a
# Y=np.array([[0,0,0,1]])
# max_index = np.argmax(y_hat, axis=1)
# print(max_index)
# y_hat[np.arange(y_hat.shape[0]), max_index] = 1
# print(y_hat)
# accuracy = np.argmax(y_hat, axis=1)==np.argmax(Y, axis=1)
# print(accuracy)
# img = cv2.imread('./mnist_img/mnist_train_10.jpg',0)
# print(img.shape)
# #img.reshape((1,28,28))
# #img = rgb2gray(img)
# print(img)
# img = np.expand_dims(img, axis=0)
# #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# print(img.shape)
# print(img)
