def old_tests():
print(backprop.final_layer_error(layer.softmax(np.array([5,2,5,1])), np.array([0,1,0,0]), np.array([5,2,5,1])))
print(layer.conv_layer(np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]), layer.init_weights(5, (2,2,3)), layer.init_biases(5), zero_pad_dimensions=(2,2)))
print(layer.conv_layer(
layer.relu(
layer.conv_layer(np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]), layer.init_weights(5, (2,2,3)), layer.init_biases(5), zero_pad_dimensions=(2,2))),
layer.init_weights(32, (2,2,5)),
layer.init_biases(32),
zero_pad_dimensions=(1,1)
).shape)
import_files.import_batch("/Users/admin/Documents/code/python/tensorflow/projects/CIFAR-10-convnet/Data/test/", 1, 256)
def test_full_net():
"""
test whether an evaluable network can be created
"""
#import
test_data = import_files.import_batch("/Users/admin/Documents/code/python/tensorflow/projects/CIFAR-10-convnet/Data/test/", 1, 10)
#weights and biases
layer1_weights = layer.init_weights(32, (4,4,3))
layer1_biases = layer.init_biases(32)
layer2_weights = layer.init_weights(128, (8192))
layer2_biases = layer.init_biases(128)
layer3_weights = layer.init_weights(10, (128))
layer3_biases = layer.init_biases(10)
output = np.empty((10, 10))
for i in range(0,9):
layer1 = layer.relu(layer.conv_layer(test_data[i], layer1_weights, layer1_biases, zero_pad_dimensions=(2,2), stride=(2,2)))
layer2 = layer.relu(layer.fulcon_layer(layer1, layer2_weights, layer2_biases))
layer3 = layer.relu(layer.fulcon_layer(layer2, layer3_weights, layer3_biases))
print(layer3)
output[i] = layer.softmax(layer3)
def _forward_pass(self, x):
# Encoder
h = deconv_layer(x,
filter_shape=[2, 2, 512, 512],
strides=[1, 2, 2, 1],
output_shape=[-1, 5, 26, 512],
padding='VALID',
name='L1')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L2')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L3')
h = deconv_layer(h,
filter_shape=[2, 2, 512, 512],
strides=[1, 2, 2, 1],
output_shape=[-1, 11, 52, 512],
padding='VALID',
name='L4')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L5')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L6')
h = deconv_layer(h,
filter_shape=[2, 2, 256, 512],
strides=[1, 2, 2, 1],
output_shape=[-1, 22, 105, 256],
padding='VALID',
name='L7')
h = conv_layer(h, filter_shape=[3, 3, 256, 256], name='L8')
h = conv_layer(h, filter_shape=[3, 3, 256, 256], name='L9')
h = deconv_layer(h,
filter_shape=[2, 2, 128, 256],
strides=[1, 2, 2, 1],
output_shape=[-1, 45, 210, 128],
padding='VALID',
name='L10')
h = conv_layer(h, filter_shape=[3, 3, 128, 128], name='L11')
h = conv_layer(h, filter_shape=[3, 3, 128, 128], name='L12')
h = deconv_layer(h,
filter_shape=[3, 3, 64, 128],
strides=[1, 2, 2, 1],
output_shape=[-1, 90, 420, 64],
name='L13')
h = conv_layer(h, filter_shape=[3, 3, 64, 64], name='L14')
h = conv_layer(h,
filter_shape=[3, 3, 64, self.output_shape[3]],
name='L15')
h = h[:, 0:self.output_shape[1], 0:self.output_shape[2], :]
return h
def main():
check =0
# main fuction
if check == 0 :
# training data
train_parser = data_loader.parse_cambridge() # class
# name list, label list, path list parser
train_name_list, train_label_list, train_path_list = train_parser.label_extract('train')
# read the data and concatinate
train_parser.writing_data_to_tfrecord(train_path_list, 6 ,'train')
# test data
test_parser = data_loader.parse_cambridge()
# name list, label list, path list parser
test_name_list, test_label_list, test_path_list = test_parser.label_extract('test')
# read the data and concatinate
test_parser.writing_data_to_tfrecord(test_path_list, 6, 'test')
check = 1
#re-read and parsing the data
batch_size = 5
epoch_size = 10
read_train_parser = data_loader.parse_cambridge()
train_iterator = read_train_parser.read_data_from_tfrecode('train', batch_size, epoch_size, True) #, train_name
train_next_element = train_iterator.get_next()
read_test_parser = data_loader.parse_cambridge()
test_iterator = read_test_parser.read_data_from_tfrecode('test', batch_size, epoch_size, False) # , test_name
test_next_element = test_iterator.get_next()
#read_train_parser.preprocessing(train_image, train_label, train_channel, train_sample)
#input_image = train_image
#output_image = train_label
#STEPS = 1000
#MINIBATCH_SIZE = 10
'''x = tf.placeholder(dtype=tf.float32,
shape=[None, 60000],
name='input')
y_ = tf.placeholder(dtype=tf.int64,
shape=[None, 1, 6],
name='output')'''
'''x_image = tf.reshape(x,[-1,1000,10,6],name='image_end')
# batch_ind = tf.placeholder(dtype=tf.int64, shape =[1])'''
x_image = train_next_element[0]
y_ = train_next_element[1]
conv1 = conv_layer(x_image, shape=[5, 5, 3, 32])
def inference(feature, k):
"""
rpn part net work
Args:
feature: a 4-D tensor [batch_size,height,width,n_channel] tensor, the output of last conv layer of feature extractor
k: a scalar indicating number of predictions per cell
Returns:
rpn_obj: a 4-D tensor [batch_size,height,width,2*k], the prediction of objectness score
rpn_box: a 4-D tensor [batch_size,height,width,4*k], the prediction of box coordinates
"""
shape = feature.get_shape().as_list()
rpn_conv = layer.conv_layer('rpn_conv', feature, [3, 3, shape[3], 256])
rpn_obj = layer.conv_layer('rpn_obj_conv', rpn_conv, [1, 1, 256, 2 * k])
rpn_box = layer.conv_layer('rpn_box_conv', rpn_conv, [1, 1, 256, 4 * k])
return rpn_obj, rpn_box
def _forward_pass(self, x):
# Encoder
h = deconv_layer(x,
filter_shape=[3, 3, 1024, 2048],
strides=[1, 2, 2, 1],
output_shape=[-1, 6, 28, 1024],
name='L1')
h = conv_layer(h, filter_shape=[3, 3, 1024, 1024], name='L2')
h = conv_layer(h, filter_shape=[3, 3, 1024, 1024], name='L3')
h = deconv_layer(h,
filter_shape=[3, 3, 512, 1024],
strides=[1, 2, 2, 1],
output_shape=[-1, 12, 56, 512],
name='L4')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L5')
h = conv_layer(h, filter_shape=[3, 3, 512, 512], name='L6')
h = deconv_layer(h,
filter_shape=[3, 3, 256, 512],
strides=[1, 2, 2, 1],
output_shape=[-1, 24, 112, 256],
name='L7')
h = conv_layer(h, filter_shape=[3, 3, 256, 256], name='L8')
h = conv_layer(h, filter_shape=[3, 3, 256, 256], name='L9')
h = deconv_layer(h,
filter_shape=[3, 3, 128, 256],
strides=[1, 2, 2, 1],
output_shape=[-1, 48, 224, 128],
name='L10')
h = conv_layer(h, filter_shape=[3, 3, 128, 128], name='L11')
h = conv_layer(h, filter_shape=[3, 3, 128, 128], name='L12')
h = deconv_layer(h,
filter_shape=[3, 3, 64, 128],
strides=[1, 2, 2, 1],
output_shape=[-1, 96, 448, 64],
name='L13')
h = conv_layer(h, filter_shape=[3, 3, 64, 64], name='L14')
h = conv_layer(h,
filter_shape=[3, 3, 64, self.output_shape[3]],
name='L15')
h = h[:, 0:self.output_shape[1], 0:self.output_shape[2], :]
return h
def inference(images, keep_prob):
# images [N, 3, 33, 33]
conv1 = conv_layer(images, 64, 'conv1')
conv2 = conv_layer(conv1, 64, 'conv2')
pool1 = max_pooling_layer(conv2, layer_name='max_pool_1')
conv3 = conv_layer(pool1, 128, 'conv3')
conv4 = conv_layer(conv3, 128, 'conv4')
pool2 = max_pooling_layer(conv4, layer_name='max_pool_2')
conv5 = conv_layer(pool2, 256, 'conv5')
conv6 = conv_layer(conv5, 256, 'conv6')
pool3 = max_pooling_layer(conv6, layer_name='max_pool_3')
conv7 = conv_layer(pool3, 512, 'conv7')
conv8 = conv_layer(conv7, 512, 'conv8')
pool4 = max_pooling_layer(conv8, layer_name='max_pool_4')
'''
Global average pooling
gap = gap_layer(conv8, layer_name='global_avg_pool')
fc = fc_layer(gap, 128, 'fc', use_DW=True)
with tf.name_scope('dropout'):
dropped = tf.nn.dropout(fc, keep_prob)
logits = fc_layer(input_tensor=dropped, output_dim=2, layer_name='logits', act_ftn=tf.identity, use_DW=True)
return logits
'''
flat = flatten(pool4)
fc1 = fc_layer(input_tensor = flat, output_dim = 512, layer_name = 'fc1')
fc2 = fc_layer(input_tensor = fc1, output_dim = 256, layer_name = 'fc2')
fc3 = fc_layer(input_tensor = fc2, output_dim = 128, layer_name = 'fc3')
with tf.name_scope('dropout'):
dropped = tf.nn.dropout(fc3, keep_prob)
logits = fc_layer(input_tensor=dropped, output_dim=2, layer_name='logits', act_ftn=tf.identity)
return logits
def _forward_pass(self, x):
# Encoder
h1 = conv_layer(x, filter_shape=[3, 3, 3, 64],
name='L1') # (90, 420, 64)
h2 = conv_layer(h1, filter_shape=[3, 3, 64, 64], name='L2')
h3 = pooling_layer(h2,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
name='L3') # (45, 210, 64)
h4 = conv_layer(h3, filter_shape=[3, 3, 64, 256], name='L4')
h5 = conv_layer(h4, filter_shape=[3, 3, 256, 256], name='L5')
h6 = pooling_layer(h5,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
name='L6') # (23, 105, 128)
h7 = conv_layer(h6, filter_shape=[3, 3, 256, 512], name='L7')
h8 = conv_layer(h7, filter_shape=[3, 3, 512, 512], name='L8')
h9 = pooling_layer(h8,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
name='L9') # (12, 53, 256)
h10 = conv_layer(h9, filter_shape=[3, 3, 512, 1024], name='L10')
h11 = conv_layer(h10, filter_shape=[3, 3, 1024, 1024], name='L11')
# Decoder
h12 = deconv_layer(h11,
filter_shape=[3, 3, 512, 1024],
strides=[1, 2, 2, 1],
output_shape=[-1, 24, 106, 512],
name='L12')
h12 = tf.concat([h12[:, 0:-1, 0:-1, :], h8], axis=3)
h13 = conv_layer(h12, filter_shape=[3, 3, 1024, 512], name='L13')
h14 = conv_layer(h13, filter_shape=[3, 3, 512, 512], name='L14')
h15 = deconv_layer(h14,
filter_shape=[3, 3, 256, 512],
strides=[1, 2, 2, 1],
output_shape=[-1, 46, 210, 256],
name='L15')
h15 = tf.concat([h15[:, 0:-1, :, :], h5], axis=3)
h16 = conv_layer(h15, filter_shape=[3, 3, 512, 256], name='L16')
h17 = conv_layer(h16, filter_shape=[3, 3, 256, 256], name='L17')
h18 = deconv_layer(h17,
filter_shape=[3, 3, 64, 256],
strides=[1, 2, 2, 1],
output_shape=[-1, 90, 420, 64],
name='L18')
h18 = tf.concat([h18, h2], axis=3)
h19 = conv_layer(h18, filter_shape=[3, 3, 128, 64], name='L19')
h20 = conv_layer(h19, filter_shape=[3, 3, 64, 64], name='L20')
h21 = conv_layer(h20,
filter_shape=[1, 1, 64, self.output_shape[3]],
name='L21',
non_linear=None)
return h21
def vgg16(image):
conv1_1 = layer.conv_layer('conv1_1',image,[3,3,3,64])
conv1_2 = layer.conv_layer('conv1_2',conv1_1,[3,3,64,64])
pool1 = layer.pool_layer('pool1',conv1_2)
conv2_1 = layer.conv_layer('conv2_1',pool1,[3,3,64,128])
conv2_2 = layer.conv_layer('conv2_2',conv2_1,[3,3,128,128])
pool2 = layer.pool_layer('pool2',conv2_2)
conv3_1 = layer.conv_layer('conv3_1',pool2,[3,3,128,256])
conv3_2 = layer.conv_layer('conv3_2',conv3_1,[3,3,256,256])
conv3_3 = layer.conv_layer('conv3_3',conv3_2,[3,3,256,256])
pool3 = layer.pool_layer('pool3',conv3_3)
conv4_1 = layer.conv_layer('conv4_1',pool3,[3,3,256,512])
conv4_2 = layer.conv_layer('conv4_2',conv4_1,[3,3,512,512])
conv4_3 = layer.conv_layer('conv4_3',conv4_2,[3,3,512,512])
pool4 = layer.pool_layer('pool4',conv4_3)
conv5_1 = layer.conv_layer('conv5_1',pool4,[3,3,512,512])
conv5_2 = layer.conv_layer('conv5_2',conv5_1,[3,3,512,512])
conv5_3 = layer.conv_layer('conv5_3',conv5_2,[3,3,512,512])
return conv5_3
def build_wide_resnet(x, num_classes, N, k, block, prob = None):
channels = [3, 16, 16 * k, 32 * k, 64 * k]
layers = []
# conv1
# conv1 = layer.bn_relu_conv(x, "conv1", channels[0], channels[1], 3)
conv1 = layer.conv_bn_relu(x, "conv1", channels[0], channels[1], 3)
layers.append(conv1)
# conv2
# 1st
before20 = layers[-1]
conv20 = layer.conv_layer(before20, "conv20", [1, 1, channels[1], channels[2]])
# conv20b = block(before20, "conv20b", prob, channels[1], channels[2]) if block is dropout else block(before20, "conv20b", channels[1], channels[2])
conv20b_ = layer.conv_bn_relu(before20, "conv20b_", channels[1], channels[2], 3)
conv20b = layer.conv_layer(conv20b_, "conv20b", [3, 3, channels[2], channels[2]])
output20 = layer.bn_relu(conv20 + conv20b, "output20")
layers.append(output20)
# others
for n in range(1, N):
before2n = tf.identity(layers[-1])
# conv2n = layer.conv_layer(before2n, "conv2%d" % n, [3, 3, channels[2], channels[2]])
conv2nb = block(layers[-1], "conv2%db" % n, prob, channels[2], channels[2]) if block is dropout else block(layers[-1], "conv2%db" % n, channels[2], channels[2])
output2n = layer.bn_relu(before2n + conv2nb, "output2%d" % n)
layers.append(output2n)
# downsampling0
#downsampling0 = layer.avg_pool_layer(layers[-1], "downsampling0", [1, 2, 2, 1])
downsampling0 = layer.max_pool_layer(layers[-1], "downsampling0", [1, 2, 2, 1])
layers.append(downsampling0)
# conv3
# 1st
before30 = layers[-1]
conv30 = layer.conv_layer(before30, "conv30", [1, 1, channels[2], channels[3]])
# conv30b = block(before30, "conv30b", prob, channels[2], channels[3]) if block is dropout else block(before30, "conv30b", channels[2], channels[3])
conv30b_ = layer.conv_bn_relu(before30, "conv30b_", channels[2], channels[3], 3)
conv30b = layer.conv_layer(conv30b_, "conv30b", [3, 3, channels[3], channels[3]])
output30 = layer.bn_relu(conv30 + conv30b, "output30")
layers.append(output30)
# others
for n in range(1, N):
before3n = tf.identity(layers[-1])
# conv3n = layer.conv_layer(before3n, "conv3%d" % n, [3, 3, channels[3], channels[3]])
conv3nb = block(layers[-1], "conv3%db" % n, prob, channels[3], channels[3]) if block is dropout else block(layers[-1], "conv3%db" % n, channels[3], channels[3])
output3n = layer.bn_relu(before3n + conv3nb, "output3%d" % n)
layers.append(output3n)
# downsampling1
#downsampling1 = layer.avg_pool_layer(layers[-1], "downsampling1", [1, 2, 2, 1])
downsampling1 = layer.max_pool_layer(layers[-1], "downsampling1", [1, 2, 2, 1])
layers.append(downsampling1)
# conv4
# 1st
before40 = layers[-1]
conv40 = layer.conv_layer(before40, "conv40", [1, 1, channels[3],channels[4]])
# conv40b = block(before40, "conv40b", prob, channels[3], channels[4]) if block is dropout else block(before40, "conv40b", channels[3], channels[4])
conv40b_ = layer.conv_bn_relu(before40, "conv40b_", channels[3], channels[4], 3)
conv40b = layer.conv_layer(conv40b_, "conv40b", [3, 3, channels[4], channels[4]])
output40 = layer.bn_relu(conv40 + conv40b, "output40")
layers.append(output40)
# others
for n in range(1, N):
before4n = tf.identity(layers[-1])
# conv4n = layer.conv_layer(before4n, "conv4%d" % n, [3, 3, channels[4], channels[4]])
conv4nb = block(layers[-1], "conv4%db" % n, prob, channels[4], channels[4]) if block is dropout else block(layers[-1], "conv4%db" % n, channels[4], channels[4])
output4n = layer.bn_relu(before4n + conv4nb, "output4%d" % n)
layers.append(output4n)
# avg pooling
avg_pool = layer.avg_pool_layer(layers[-1], name = "avg_pool", pooling_size = [1, 8, 8, 1])
layers.append(avg_pool)
# flatten and fully connected
flatten = layer.flatten_layer(layers[-1])
fc = layer.fc_layer(flatten, num_classes, "fc")
layers.append(fc)
sm = tf.nn.softmax(layers[-1], name = "prediction")
layers.append(sm)
return layers[-1]
def main():
## ---------------------------------------------------------------------------------------------------------------------
## hyper parameter
class_num = 6
batch_size_in = 10
batch_size = 64
batch_label = 512
height_ = 200
width_ = 9
## ---------------------------------------------------------------------------------------------------------------------
## Save dir
now = datetime.utcnow().strftime("%Y%m%d%H%M%S")
board_logdir = "C:\\Users\\SNUGL\\tensorboard\\"
ckpt_logdir = "D:\dev\jejucamp-seoyeon\classification\\model_ckpt\\"
## ---------------------------------------------------------------------------------------------------------------------
## data checking
check = 1 # 데이터 저장 안됬을 시 0, 데이터 저장 됬을 시 1
check2 = 0 # ckpt 로딩 안할시 0 , ckpt 로딩할 시 1
## ---------------------------------------------------------------------------------------------------------------------
## data loader
if check == 0 :
# training data
train_parser = data_loader2.parse_cambridge() # class
# name list, label list, path list parser
train_name_list, train_label_list, train_path_list = train_parser.label_extract('train')
# read the data and concatinate
train_data, train_label = train_parser.loading_data(train_path_list, height_, width_, None, 'train')
np.save('train_data_2', train_data)
np.save('train_label_2', train_label)
# test data
test_parser = data_loader2.parse_cambridge()
# name list, label list, path list parser
test_name_list, test_label_list, test_path_list = test_parser.label_extract('test')
# read the data and concatinate
test_data, test_label = test_parser.loading_data(test_path_list, height_, width_, None, 'test')
np.save('test_data_2', test_data)
np.save('test_label_2', test_label)
check = 2
if check == 1 :
train_data = np.load('train_data_2.npy')
train_label = np.load('train_label_2.npy')
test_data = np.load('test_data_2.npy')
test_label = np.load('test_label_2.npy')
check = 2
## ---------------------------------------------------------------------------------------------------------------------
## check point loading
## ---------------------------------------------------------------------------------------------------------------------
## config env
# training constant config
epochs = 1000
iter_ = 1
lr = .0001
#e-5
num_end = []
for w in range(64) :
num_end.append(height_)
total_sample = np.shape(train_data)[0]
total_batch = int(np.shape(train_data)[0] / batch_size)
print(epochs)
## ---------------------------------------------------------------------------------------------------------------------
## model defined
jeju_graph = tf.Graph()
with jeju_graph.as_default():
lstm_model = lstm.LstmModel()
# input : A 'batch_size' x 'max_frames' x 'num_features'
# max_frames : time series,
# num_feature : contributes
x = tf.placeholder(dtype=tf.float32,
shape=[None, height_, width_],
name='input')
x = tf.reshape(x, [1, 64, height_, width_])
y = tf.placeholder(dtype=tf.int64,
shape=[None, class_num],
name='output')
conv1 = conv_layer(x, shape=[3, 3, 9, 9])
conv1_pool = max_pool_3x3(conv1)
conv2 = conv_layer(conv1_pool, shape=[3, 3, 9, 9])
conv2_pool = max_pool_3x3(conv2)
conv3 = conv_layer(conv2_pool, shape=[5, 5, 9, 9])
conv3_pool = max_pool_3x3(conv3)
conv3_pool = tf.reshape(conv3_pool,[-1, height_, width_])
with tf.name_scope('output'):
output = lstm_model.create_model(conv3_pool, class_num, num_end)
tf.summary.histogram('output',output)
# create training op
opt = tf.train.AdamOptimizer(learning_rate=lr)
with tf.name_scope('loss_l'):
loss_l = tf.losses.softmax_cross_entropy(onehot_labels=y, logits=output) # cross_entroy : classification , l2_loss : regression
tf.summary.scalar('loss_l',loss_l)
training_op = opt.minimize(loss=loss_l)
# prediction
pred = tf.argmax(output, 1)
pred_y = tf.argmax(y, 1)
diff = tf.equal(pred, pred_y)
hey = tf.cast(diff, tf.float32)
predict_accuracy = tf.reduce_mean(hey)
with tf.name_scope('accuracy'):
tf.summary.scalar('accuracy',predict_accuracy)
merged = tf.summary.merge_all()
## ---------------------------------------------------------------------------------------------------------------------
## savor
tf_saver = tf.train.Saver() #max_to_keep=7, keep_checkpoint_every_n_hours=1
## ---------------------------------------------------------------------------------------------------------------------
## Tensorboard
train_writer = tf.summary.FileWriter(logdir=board_logdir + '/train', graph = jeju_graph)
test_writer = tf.summary.FileWriter(logdir=board_logdir + '/test', graph=jeju_graph)
## ---------------------------------------------------------------------------------------------------------------------
# session
with tf.Session(graph=jeju_graph) as sess:
if check2 == 1 :
tf_saver.restore(sess, os.path.join("D:\\dev\\jejucamp-seoyeon\\classification\\model_ckpt","ckpt-216310"))
sess.run(tf.global_variables_initializer())
# prepare session
tr_loss_hist = []
global_step = 0
save_accuracy = []
test_len = test_data.shape[0]
train_len = train_data.shape[0]
display_num = 0
sum_accuracy = 0
for e in range(epochs) :
for i in range(total_batch) :
random_idex = random.randrange(0, test_len - batch_size)
batch_validation_data = test_data[random_idex:random_idex + batch_size, ...]
batch_validation_label = test_label[random_idex:random_idex + batch_size, ...]
data_start_index = i * batch_size
data_end_index = (i + 1) * batch_size
batch_train_data = train_data[data_start_index:data_end_index, ...]
batch_train_label = train_label[data_start_index:data_end_index]
batch_train_data.reshape([batch_size, height_, width_])
avg_tr_loss = 0
tr_step = 0
try:
for h in range(iter_) : # for 문으로 tr 고정
batch_train_data =batch_train_data.reshape([1, 64, 200, 9])
_, tr_loss, summary1 = sess.run(fetches=[training_op, loss_l, merged], feed_dict = {x: batch_train_data,
y: batch_train_label})
#print('epoch : {:3}, batch_step : {:3}, tr_step : {:3}, tr_loss : {:.5f}'.format(e + 1, i +1, tr_step + 1, tr_loss))
avg_tr_loss += tr_loss
tr_step += 1
global_step += 1
except tf.errors.OutOfRangeError:
pass
avg_tr_loss /= tr_step
tr_loss_hist.append(avg_tr_loss)
batch_validation_data = batch_validation_data.reshape([1, 64, 200, 9])
acc = predict_accuracy.eval(feed_dict={x: batch_validation_data,
y: batch_validation_label}, session=sess)
summary2 = merged.eval(feed_dict={x: batch_validation_data,
y: batch_validation_label}, session=sess)
display_num = display_num + 1
sum_accuracy = sum_accuracy + acc
if(display_num%10==0):
avg_save_accuracy = sum_accuracy/display_num
print('epoch : {:3}, batch_step : {:3}/{:3}, avg_tr_loss : {:.5f}, prediction : {:.5f}'.format(e + 1,
i + 1,
total_batch,
avg_tr_loss,
acc))
tf_saver.save(sess, os.path.join(ckpt_logdir,"ckpt"), global_step=global_step)
display_num = 0
sum_accuracy = 0
save_accuracy.append(avg_save_accuracy)
train_writer.add_summary(summary1, global_step)
test_writer.add_summary(summary2, global_step)
## ---------------------------------------------------------------------------------------------------------------------
## plotting
''' plt.plot(tr_loss_hist, label='train')
'''x = tf.placeholder(dtype=tf.float32,
shape=[None, 60000],
name='input')
y_ = tf.placeholder(dtype=tf.int64,
shape=[None, 1, 6],
name='output')'''
'''x_image = tf.reshape(x,[-1,1000,10,6],name='image_end')
# batch_ind = tf.placeholder(dtype=tf.int64, shape =[1])'''
x_image = train_next_element[0]
y_ = train_next_element[1]
conv1 = conv_layer(x_image, shape=[5, 5, 3, 32])
conv1_pool = max_pool_2x2(conv1)
conv2 = conv_layer(conv1_pool, shape=[3, 3, 32, 64])
conv2_pool = max_pool_2x2(conv2)
conv2_flat = tf.reshape(conv2_pool, [-1, 5 * 500 * 64])
full_1 = tf.nn.relu(full_layer(conv2_flat, 1024))
keep_prob = tf.placeholder(tf.float32)
full1_drop = tf.nn.dropout(full_1, keep_prob=keep_prob)
y_conv = full_layer(full1_drop, 6)
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv, labels=y_))
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, tf.float32))
