def write_tfrecord(decode_path, write_path):
img_data = basis_code.basis_decode(decode_path)
#维度为6x10x3
img_data = tf.image.resize_images(img_data, [6, 10], method=1)
with tf.Session() as sess:
img_value = sess.run(img_data)
#总共写入多少文件
num_shards = 2
#每个文件写入多少数据
instance_per_shard = 3
for i in range(2):
#将文件分为多个文件。以便读取时方便匹配
filename = os.path.join(
write_path,
"data.tfrecords-" + str(i) + ".5d-of-" + str(num_shards) + ".5d")
writer = tf.python_io.TFRecordWriter(filename)
for j in range(instance_per_shard):
if i == 1:
j = j + 3
Log_Util.getlogger("write img" + str(j)).info(img_value[j])
img_raw = img_value[j].tostring()
example = tf.train.Example(features=tf.train.Features(
feature={
"labels": _int64_feature(j),
"img_data": _byte_feature(img_raw)
}))
try:
writer.write(example.SerializeToString())
except IOError:
print("write error!")
writer.close()
writer.close()
def read_TFRercod():
#创建一个reader来获取TFRecord文件的样例
reader = tf.TFRecordReader()
#创建一个队列来维护输入文件列表
fileName_queue = tf.train.string_input_producer([FILENAME])
#从文件中读取一个样例。也可以使用read_up_to函数一次性读取多个样例
_, serialized_example = reader.read(fileName_queue)
#解析读入的一个样例，如果需要解析多个样例，可以用parse_example
features = tf.parse_single_example(
serialized_example,
features={
#必须和写入时的类型一致
'pixels': tf.FixedLenFeature([], tf.int64),
'labels': tf.FixedLenFeature([], tf.int64),
'image_raw': tf.FixedLenFeature([], tf.string),
})
#tf.decode_raw可以将字符串解析成图像对应的像素数组.必须和读取mnist数据集时设置的类型一致
image = tf.decode_raw(features['image_raw'], tf.uint8)
#转换类型，把tf.int64转换为tf.int32
pixels = tf.cast(features['pixels'], tf.int32)
labels = tf.cast(features['labels'], tf.int32)
sess = tf.Session()
#启动多线程处理输入数据
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
#每次运行可以读取TFRecord文件中的一个样例
# for i in range(10):
Log_Util.getlogger("read").info(sess.run([image, pixels, labels]))
pass
def run_eval(sess, test_x, test_y):
X, y = tf.data.Dataset.from_tensor_slices(
(test_x, test_y)).batch(1).make_one_shot_iterator().get_next()
#调用模型得到预测结果。这里不需要输入真实的y值
with tf.variable_scope("model", reuse=True):
prediction, _, _ = lstm_model(X, [0.0], False)
#将预测结果存入一个数组
predictions = []
labels = []
for i in range(TESTING_EXAMPLES):
p, l = sess.run([prediction, y])
predictions.append(p)
labels.append(l)
Log_Util.getlogger("labels1").info(labels)
Log_Util.getlogger("predictions1").info(predictions)
#计算rmse作为评估指标
predictions = np.array(predictions).squeeze()
labels = np.array(labels).squeeze()
rmse = np.sqrt(((predictions - labels)**2).mean(axis=0))
print("Mean Square Error is: %f" % rmse)
Log_Util.getlogger("labels2").info(labels)
Log_Util.getlogger("predictions2").info(predictions)
#对预测的sin函数曲线进行绘图
plt.figure()
plt.plot(labels, label="real_sin")
plt.plot(predictions, label="predictions")
plt.legend()
plt.show()
def read_tfrecord(filepath):
files = tf.train.match_filenames_once(
os.path.join(filepath, "data.tfrecords-*"))
#通过tf.train.string_input_producer函数创建输入队列，输入队列中的文件列表为tf.train.match_filenames_once函数获取的文件列表。这里将shuffle参数设置为False.
#来避免随机打乱读文件的顺序，但一般在解决真实问题时，会将shuffle参数设置为True
filename_queue = tf.train.string_input_producer(files, shuffle=False)
reader = tf.TFRecordReader()
_, seriallzed_example = reader.read(filename_queue)
#img_data和labels要和写入的名字保持一致
example = tf.parse_single_example(seriallzed_example,
features={
"img_data":
tf.FixedLenFeature([], tf.string),
"labels":
tf.FixedLenFeature([], tf.int64)
})
image = tf.decode_raw(example["img_data"], tf.uint8)
labels = tf.cast(example["labels"], tf.int32)
with tf.Session() as sess:
#虽然在本段程序中没有声明任何变量，但使用tf.train.match_filenames_once函数时需要初始化一些变量
tf.local_variables_initializer().run()
Log_Util.getlogger("file names").info(sess.run(files))
#声明tf.train.Coordinator类来协同不同线程，并启动线程
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
for i in range(6):
Log_Util.getlogger("read img data").info(sess.run(image))
Log_Util.getlogger("read labels").info(sess.run(labels))
coord.request_stop()
coord.join(threads)
print("all thread stop!")
def method_one(filepath):
before_img_data = basis_decode(filepath)
if before_img_data.dtype != tf.float32:
#这里tf.image.decode_png 得到的是uint8格式，范围在0-255之间，经过convert_image_dtype 就会被转换为区间在0-1之间的float32格式
#大多数API支持整数和实数的类型的输入。如果输入时整数类型，这些API会在内部将输入转化为实数后处理，再将输出转化为整数。
#如果有多个处理步骤，在整数和实数之间的反复转化将导致精度损失，因此推荐在图像处理前将其转化为实数类型。
before_img_data = tf.image.convert_image_dtype(before_img_data,
tf.float32)
for i in range(4):
#第一个参数为原始图像。第二个参数为调整后的图像大小，method参数给出了调整图像大小的算法，注意，如果输入数据为unit8格式，
# 那么输出将是0~255之间的实数，不方便后续处理，所以建议在调整图像大小之前先转化为实数类型，用tf.image.convert_image_dtype函数
img_data = tf.image.resize_images(before_img_data, [300, 300],
method=i)
with tf.Session() as sess:
#原始的图像维度为(1105, 681, 3)
#画出改变大小的图像
basis.drawing(sess.run(img_data))
#获取编码路径
endoce_path = get_encode_path(filepath, i)
Log_Util.getlogger("编码路径为:").info(endoce_path)
#编码到新的图片中
basis_encode(img_data, endoce_path)
def batch_test(filepath):
#获取解析的数据
img_raw, label_raw = read_file(filepath)
#一个batch中样例的个数
batch_size = 3
#组合样例的队列中最多可以存储的样例个数，一般来说这个队列的大小会和每个batch的大小相关。
capacity = 1000 + 3 * batch_size
#使用tr.train.batch函数组合样例，[img_raw, label_raw]参数给出了需要组合的元素，一般img和label分别代表训练样本和这个样本对应的正确标签。batch_size参数给出了每个batch
#中样例的个数，capacity给出了队列的最大容量，当队列长度等于容量时，Tensorflow将暂停入队操作，而只是等待元素出队。当元素个数小于容量时，Tensorflow将自动重新启动入队操作。
img_batch, label_batch = tf.train.batch([img_raw, label_raw],
batch_size=batch_size,
capacity=capacity)
with tf.Session() as sess:
tf.local_variables_initializer().run()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
# for i in range(6):
Log_Util.getlogger("img batch").info(sess.run(img_batch))
Log_Util.getlogger("img labels").info(sess.run(label_batch))
coord.request_stop()
coord.join(threads)
print("all threads stop!")
def shuffle_batch_test(filepath):
#获取解析的数据
img_raw, label_raw = read_file(filepath)
#一个batch中样例的个数
batch_size = 3
#组合样例的队列中最多可以存储的样例个数，一般来说这个队列的大小会和每个batch的大小相关。
capacity = 1000 + 3 * batch_size
#shuffle_batch和batch函数基本一致，但是min_after_dequeue参数是shuffle_batch函数所独有的。min_after_dequeue参数限制了出队时队列中元素的最少个数，
# 当队列中元素太少时，随机打乱样例顺序的作用就不大了。
img_batch, label_batch = tf.train.shuffle_batch([img_raw, label_raw],
batch_size=batch_size,
capacity=capacity,
min_after_dequeue=30)
with tf.Session() as sess:
tf.local_variables_initializer().run()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
# for i in range(6):
Log_Util.getlogger("img batch").info(sess.run(img_batch))
Log_Util.getlogger("img labels").info(sess.run(label_batch))
coord.request_stop()
coord.join(threads)
print("all threads stop!")
def inception_test(input):
#加载slim库
slim = tf.contrib.slim
#slim.arg_scope函数可以用于设置默认的参数取值。slim.arg_scope函数的第一个参数是一个函数列表，在这个列表中的函数将使用默认的参数取值。比如通过如下的定义，调用
#slim.conv2d(input, 32, [1, 1])函数时会自动加上stride=1和padding="SAME"的参数。如果在函数调用时指定了stride，那么这里设置的默认值就不会使用。通过这种方式可以进一步减少冗余的代码
with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],
stride=1,
padding="SAME"):
#为每一个inception模型声明一个统一的变量命名空间
with tf.variable_scope("Mixed_7c"):
#给inception模型中每一个路径声明一个命名空间
with tf.variable_scope("Branch_0"):
#实现一个过滤器边长为1，深度为320的卷积层。输出为[batch, 28, 28, 320]
branch_0 = slim.conv2d(input,
320, [1, 1],
scope="Conv2d_0a_1x1")
Log_Util.getlogger("branch_0").info(branch_0.shape)
#Inception模型的第二条路径，这条计算路径上的结构本省也是一个Inception结构
with tf.variable_scope("Branch_1"):
#实现一个过滤器边长为1，深度为384的卷积层.输出为[batch, 28, 28, 384]
branch_1 = slim.conv2d(input,
384, [1, 1],
scope="Conv2d_0a_1x1")
Log_Util.getlogger("branch_1_1").info(branch_1.shape)
#concat函数可以将多个矩阵拼接起来。第一个参数指定了拼接的维度，这里的3代表了矩阵是在深度这个维度上进行的拼接。输出为[batch, 28, 28, 768]
branch_1 = tf.concat([
slim.conv2d(branch_1, 384, [1, 3], scope="Conv2d_0b_1x3"),
slim.conv2d(branch_1, 384, [3, 1], scope="Conv2d_0c_3x1")
], 3)
Log_Util.getlogger("branch_1_2").info(branch_1.shape)
#Inception模型的第三条路径，这条计算路径上的结构本省也是一个Inception结构
with tf.variable_scope("Branch_2"):
#实现一个过滤器边长为1，深度为448的卷积层.输出为[batch, 28, 28, 448]
branch_2 = slim.conv2d(input,
448, [1, 1],
scope="Conv2d_0a_1x1")
Log_Util.getlogger("branch_2_1").info(branch_2.shape)
#输出为[batch, 28, 28, 384]
branch_2 = slim.conv2d(branch_2,
384, [3, 3],
scope="Conv2d_0b_3x3")
Log_Util.getlogger("branch_2_2").info(branch_2.shape)
#concat函数可以将多个矩阵拼接起来。第一个参数指定了拼接的维度，这里的3代表了矩阵是在深度这个维度上进行的拼接。输出为[batch, 28, 28, 768]
branch_2 = tf.concat([
slim.conv2d(branch_2, 384, [1, 3], scope="Conv2d_0c_1x3"),
slim.conv2d(branch_2, 384, [3, 1], scope="Conv2d_0d_3x1")
], 3)
Log_Util.getlogger("branch_2_3").info(branch_2.shape)
#Inception模型的第四条路径，这条计算路径上的结构本省也是一个Inception结构
with tf.variable_scope("Branch_3"):
#实现一个过滤器边长为1，深度为320的卷积层.输出为[batch, 28, 28, 1]
branch_3 = slim.avg_pool2d(input, [3, 3],
scope="AvgPool_0a_3x3")
Log_Util.getlogger("branch_3_1").info(branch_3.shape)
#输出为[batch, 28, 28, 192]
branch_3 = slim.conv2d(branch_3,
192, [1, 1],
scope="Conv2d_0b_1x1")
Log_Util.getlogger("branch_3_2").info(branch_3.shape)
#当前Inception模型的最后输出是由上面4个计算结果拼接得到的,输出为[batch, 28, 28, 2048]
net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
Log_Util.getlogger("final").info(net.shape)
return net
Log_Util.getlogger("labels2").info(labels)
Log_Util.getlogger("predictions2").info(predictions)
#对预测的sin函数曲线进行绘图
plt.figure()
plt.plot(labels, label="real_sin")
plt.plot(predictions, label="predictions")
plt.legend()
plt.show()
#用正玄函数生成训练和测试数据集合
#numpy.linspace函数可以创建一个等差序列的数组，它常用的参数有三个参数，第一个参数表示起始值，第二个参数表示终止值，第三个参数表示数列的长度。例如,linespace(1,10,10)
#产生的数组是array([1,2,3,4,5,6,7,8,9,10])
test_start = (TRAINING_EXAMPLES + TIMESTEPS) * SAMPLE_GAP
Log_Util.getlogger("test start").info(test_start)
test_end = test_start + (TESTING_EXAMPLES + TIMESTEPS) * SAMPLE_GAP
Log_Util.getlogger("test end").info(test_end)
train_X, train_y = generate_data(
np.sin(
np.linspace(0,
test_start,
TRAINING_EXAMPLES + TIMESTEPS,
dtype=np.float32)))
Log_Util.getlogger("train X").info(train_X)
Log_Util.getlogger("train y").info(train_y)
test_X, test_y = generate_data(
np.sin(
np.linspace(test_start,
test_end,
TESTING_EXAMPLES + TIMESTEPS,
if img_data.dtype != tf.float32:
img_data = tf.image.convert_image_dtype(img_data, tf.float32)
croped = tf.image.resize_image_with_crop_or_pad(img_data, 800, 500)
padded = tf.image.resize_image_with_crop_or_pad(img_data, 1500, 1000)
with tf.Session() as sess:
basis.drawing(sess.run(croped))
basis.drawing(sess.run(padded))
basis_encode(croped, get_encode_path(filepath, 1))
basis_encode(padded, get_encode_path(filepath, 2))
#还支持通过比例调整图片大小
def method_three(filepath):
img_data = basis_decode(filepath)
if img_data.dtype != tf.float32:
img_data = tf.image.convert_image_dtype(img_data, tf.float32)
central_cropped = tf.image.central_crop(img_data, 0.5)
with tf.Session() as sess:
basis.drawing(sess.run(central_cropped))
basis_encode(central_cropped, get_encode_path(filepath, 1))
if __name__ == "__main__":
filepath = get_andclean_image()
Log_Util.getlogger("原始图片路径为:").info(filepath)
# method_one(filepath)
# method_two(filepath)
method_three(filepath)
#还有其他的填充或者裁剪给定区域的图像，比如：tf.image.crop_to_bounding_box和tf.image.pad_to_bounding_box，这两个函数要求给出的尺寸满足一定的要求
def train(mnist):
x = tf.placeholder(dtype=tf.float32,
shape=[
BATCH_SIZE, mnist_inference.IMAGE_SIZE,
mnist_inference.IMAGE_SIZE,
mnist_inference.NUM_CHANNELS
],
name="x-input")
y_ = tf.placeholder(dtype=tf.float32,
shape=[None, mnist_inference.NUM_LABELS],
name="y-input")
#定义正则化
regularizer = tf.contrib.layers.l2_regularizer(REGULARIZER_RATE)
#获取前向传播结果
y = mnist_inference.inference(x, False, regularizer)
#定义滑动平均模型、损失函数、指数衰减法、优化器
global_step = tf.Variable(0, trainable=False)
variable_average = tf.train.ExponentialMovingAverage(
MOVING_AVERAGE_DECAY, global_step)
average_op = variable_average.apply(tf.trainable_variables())
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=y, labels=tf.argmax(y_, 1))
cross_entropy_mean = tf.reduce_mean(cross_entropy)
loss = cross_entropy_mean + tf.add_n(tf.get_collection("losses"))
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE, global_step, mnist.train.num_examples / BATCH_SIZE,
LEARNING_RATE_DECAY)
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(
loss, global_step=global_step)
#持久化模型
saver = tf.train.Saver()
with tf.control_dependencies([train_step, average_op]):
train_op = tf.no_op("train")
with tf.Session() as sess:
tf.global_variables_initializer().run()
#训练过程
for i in range(TRAINING_STEPS):
xs, ys = mnist.train.next_batch(BATCH_SIZE)
input_tensor = np.reshape(
xs, (BATCH_SIZE, mnist_inference.IMAGE_SIZE,
mnist_inference.IMAGE_SIZE, mnist_inference.NUM_CHANNELS))
print(i)
_, loss_value, step = sess.run([train_op, loss, global_step],
feed_dict={
x: input_tensor,
y_: ys
})
if i % 1000 == 0:
# print("After %d training step(s),loss on training " "batch is %g ." % (step, loss_value))
Log_Util.getlogger("loss").info(loss_value)
Log_Util.getlogger("step").info(step)
saver.save(sess,
os.path.join(MODEL_SAVE_PATH, MODEL_NAME),
global_step=global_step)
def getLogger(name):
return Log_Util.getlogger(name)
with tf.Session() as sess:
tf.global_variables_initializer().run()
# result_conv = sess.run(conv2[0])
# for i in range(27):
# drawing(result_conv[i])
# Log_Util.getlogger("weigth shape").info(weigth_conv1.shape)
# Log_Util.getlogger("weigth one").info(len(sess.run(weigth_conv1)))
# Log_Util.getlogger("weigth two").info(len(sess.run(weigth_conv1[0])))
# Log_Util.getlogger("weigth three").info(len(sess.run(weigth_conv1[0][0])))
# Log_Util.getlogger("weigth five").info(len(sess.run(weigth_conv1[0][0][0])))
#
# Log_Util.getlogger("conv2 shape").info(conv2.shape)
# Log_Util.getlogger("conv2 one").info(len(sess.run(conv2)))
# Log_Util.getlogger("conv2 two").info(len(sess.run(conv2[0])))
# Log_Util.getlogger("conv2 three").info(len(sess.run(conv2[0][0])))
# Log_Util.getlogger("conv2 five").info(len(sess.run(conv2[0][0][0])))
#
# Log_Util.getlogger("pool shape").info(pool.shape)
# Log_Util.getlogger("pool one").info(len(sess.run(pool)))
# Log_Util.getlogger("pool two").info(len(sess.run(pool[0])))
# Log_Util.getlogger("pool three").info(len(sess.run(pool[0][0])))
# Log_Util.getlogger("pool five").info(len(sess.run(pool[0][0][0])))
Log_Util.getlogger("pool shape2").info(pool_shape)
Log_Util.getlogger("pool nodes").info(nodes)
Log_Util.getlogger("pool reshape").info(reshape)
# logger.info(len(sess.run(conv2[0])))
# logger.info(sess.run(pool))
# logger.info(sess.run(pool[0][0]))
# logger.info(len(sess.run(pool[0])))
pass
import tensorflow as tf
from com.utils import Log_Util
from com.tensorflow.exercise.CNN.cnnMnist import mnist_basis as basis
#图像的编码和解码
if __name__ == "__main__":
#读取图像的原始数据
image_raw_data = tf.gfile.FastGFile("E:\\Alls\\code\\psb.jpg", 'rb').read()
with tf.Session() as sess:
#对图像进行jpeg的格式解码从而得到图像对应的三维矩阵。Tensorflow还提供了tf.image.decode_png格式的图像进行解码。解码之后的结果为一个张量
#在使用它的取值之前需要明确调用运行的过程
img_data = tf.image.decode_jpeg(image_raw_data)
Log_Util.getlogger("image decode data").info(sess.run(img_data))
Log_Util.getlogger("image decode shape").info(sess.run(img_data).shape)
basis.drawing(sess.run(img_data))
#将表示一张图像的三维矩阵重新按照jpeg格式编码并存入文件中。编码时img_data的类型必须是uint8
encode_image = tf.image.encode_jpeg(img_data)
with tf.gfile.FastGFile("E:\\Alls\\code\\psb1.jpg", 'wb') as f:
Log_Util.getlogger("image encode shape").info(encode_image)
f.write(sess.run(encode_image))