tensorflow 的 tutorial 的卷积神经网络的例子 convolutional.py
具体的网址在这里:
https://github.com/tensorflow/tensorflow/tree/r0.12/tensorflow/models
一个卷积神经网络用于股票分析的例子: https://github.com/keon/deepstock, https://github.com/keon/deepstock
- import argparse
- import gzip
- import os
- import sys
- import time
- import numpy
- import tensorflow as tf
- SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'
- WORK_DIRECTORY = '/home/hzh/tf'
- IMAGE_SIZE = 28
- NUM_CHANNELS = 1
- PIXEL_DEPTH = 255
- NUM_LABELS = 10
- VALIDATION_SIZE = 5000 # Size of the validation set.
- SEED = 66478 # Set to None for random seed.
- BATCH_SIZE = 64
- NUM_EPOCHS = 10
- EVAL_BATCH_SIZE = 64
- EVAL_FREQUENCY = 100 # Number of steps between evaluations.
- FLAGS = None
- def data_type():
- """Return the type of the activations, weights, and placeholder variables."""
- if FLAGS.use_fp16:
- return tf.float16
- else:
- return tf.float32
- def maybe_download(filename):
- """Download the data from Yann's website, unless it's already here."""
- if not tf.gfile.Exists(WORK_DIRECTORY):
- tf.gfile.MakeDirs(WORK_DIRECTORY)
- filepath = os.path.join(WORK_DIRECTORY, filename)
- return filepath
- def extract_data(filename, num_images):
- """Extract the images into a 4D tensor [image index, y, x, channels].
- Values are rescaled from [0, 255] down to [-0.5, 0.5].
- """
- print('Extracting', filename)
- with gzip.open(filename) as bytestream:
- bytestream.read(16)
- buf = bytestream.read(IMAGE_SIZE * IMAGE_SIZE * num_images * NUM_CHANNELS)
- data = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.float32)
- data = (data - (PIXEL_DEPTH / 2.0)) / PIXEL_DEPTH
- data = data.reshape(num_images, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS)
- return data
- def extract_labels(filename, num_images):
- """Extract the labels into a vector of int64 label IDs."""
- print('Extracting', filename)
- with gzip.open(filename) as bytestream:
- bytestream.read(8)
- buf = bytestream.read(1 * num_images)
- labels = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.int64)
- return labels
- def fake_data(num_images):
- """Generate a fake dataset that matches the dimensions of MNIST."""
- data = numpy.ndarray(
- shape=(num_images, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS),
- dtype=numpy.float32)
- labels = numpy.zeros(shape=(num_images,), dtype=numpy.int64)
- for image in range(num_images):
- label = image % 2
- data[image, :, :, 0] = label - 0.5
- labels[image] = label
- return data, labels
- def error_rate(predictions, labels):
- """Return the error rate based on dense predictions and sparse labels."""
- return 100.0 - (
- 100.0 *
- numpy.sum(numpy.argmax(predictions, 1) == labels) / predictions.shape[0])
- def main(_):
- if FLAGS.self_test:
- print('Running self-test.')
- train_data, train_labels = fake_data(256)
- validation_data, validation_labels = fake_data(EVAL_BATCH_SIZE)
- test_data, test_labels = fake_data(EVAL_BATCH_SIZE)
- num_epochs = 1
- else:
- # Get the data.
- train_data_filename = maybe_download('train-images-idx3-ubyte.gz')
- train_labels_filename = maybe_download('train-labels-idx1-ubyte.gz')
- test_data_filename = maybe_download('t10k-images-idx3-ubyte.gz')
- test_labels_filename = maybe_download('t10k-labels-idx1-ubyte.gz')
- # Extract it into numpy arrays.
- train_data = extract_data(train_data_filename, 60000)
- train_labels = extract_labels(train_labels_filename, 60000)
- test_data = extract_data(test_data_filename, 10000)
- test_labels = extract_labels(test_labels_filename, 10000)
- # Generate a validation set.
- validation_data = train_data[:VALIDATION_SIZE, ...]
- validation_labels = train_labels[:VALIDATION_SIZE]
- train_data = train_data[VALIDATION_SIZE:, ...]
- train_labels = train_labels[VALIDATION_SIZE:]
- num_epochs = NUM_EPOCHS
- train_size = train_labels.shape[0]
- # This is where training samples and labels are fed to the graph.
- # These placeholder nodes will be fed a batch of training data at each
- # training step using the {feed_dict} argument to the Run() call below.
- train_data_node = tf.placeholder(
- data_type(),
- shape=(BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
- train_labels_node = tf.placeholder(tf.int64, shape=(BATCH_SIZE,))
- eval_data = tf.placeholder(
- data_type(),
- shape=(EVAL_BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS))
- # The variables below hold all the trainable weights. They are passed an
- # initial value which will be assigned when we call:
- # {tf.global_variables_initializer().run()}
- conv1_weights = tf.Variable(
- tf.truncated_normal([5, 5, NUM_CHANNELS, 32], # 5x5 filter, depth 32.
- stddev=0.1,
- seed=SEED, dtype=data_type()))
- conv1_biases = tf.Variable(tf.zeros([32], dtype=data_type()))
- conv2_weights = tf.Variable(tf.truncated_normal(
- [5, 5, 32, 64], stddev=0.1,
- seed=SEED, dtype=data_type()))
- conv2_biases = tf.Variable(tf.constant(0.1, shape=[64], dtype=data_type()))
- fc1_weights = tf.Variable( # fully connected, depth 512.
- tf.truncated_normal([IMAGE_SIZE // 4 * IMAGE_SIZE // 4 * 64, 512],
- stddev=0.1,
- seed=SEED,
- dtype=data_type()))
- fc1_biases = tf.Variable(tf.constant(0.1, shape=[512], dtype=data_type()))
- fc2_weights = tf.Variable(tf.truncated_normal([512, NUM_LABELS],
- stddev=0.1,
- seed=SEED,
- dtype=data_type()))
- fc2_biases = tf.Variable(tf.constant(0.1, shape=[NUM_LABELS], dtype=data_type()))
- # We will replicate the model structure for the training subgraph, as well
- # as the evaluation subgraphs, while sharing the trainable parameters.
- def model(data, train=False):
- """The Model definition."""
- # 2D convolution, with 'SAME' padding (i.e. the output feature map has
- # the same size as the input). Note that {strides} is a 4D array whose
- # shape matches the data layout: [image index, y, x, depth].
- conv = tf.nn.conv2d(data,
- conv1_weights,
- strides=[1, 1, 1, 1],
- padding='SAME')
- # Bias and rectified linear non-linearity.
- relu = tf.nn.relu(tf.nn.bias_add(conv, conv1_biases))
- # Max pooling. The kernel size spec {ksize} also follows the layout of
- # the data. Here we have a pooling window of 2, and a stride of 2.
- pool = tf.nn.max_pool(relu,
- ksize=[1, 2, 2, 1],
- strides=[1, 2, 2, 1],
- padding='SAME')
- conv = tf.nn.conv2d(pool,
- conv2_weights,
- strides=[1, 1, 1, 1],
- padding='SAME')
- relu = tf.nn.relu(tf.nn.bias_add(conv, conv2_biases))
- pool = tf.nn.max_pool(relu,
- ksize=[1, 2, 2, 1],
- strides=[1, 2, 2, 1],
- padding='SAME')
- # Reshape the feature map cuboid into a 2D matrix to feed it to the
- # fully connected layers.
- pool_shape = pool.get_shape().as_list()
- reshape = tf.reshape(
- pool,
- [pool_shape[0], pool_shape[1] * pool_shape[2] * pool_shape[3]])
- # Fully connected layer. Note that the '+' operation automatically
- # broadcasts the biases.
- hidden = tf.nn.relu(tf.matmul(reshape, fc1_weights) + fc1_biases)
- # Add a 50% dropout during training only. Dropout also scales
- # activations such that no rescaling is needed at evaluation time.
- if train:
- hidden = tf.nn.dropout(hidden, 0.5, seed=SEED)
- return tf.matmul(hidden, fc2_weights) + fc2_biases
- # Training computation: logits + cross-entropy loss.
- logits = model(train_data_node, True)
- loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=train_labels_node))
- # L2 regularization for the fully connected parameters.
- regularizers = (tf.nn.l2_loss(fc1_weights) + tf.nn.l2_loss(fc1_biases) +
- tf.nn.l2_loss(fc2_weights) + tf.nn.l2_loss(fc2_biases))
- # Add the regularization term to the loss.
- loss += 5e-4 * regularizers
- # Optimizer: set up a variable that's incremented once per batch and
- # controls the learning rate decay.
- batch = tf.Variable(0, dtype=data_type())
- # Decay once per epoch, using an exponential schedule starting at 0.01.
- learning_rate = tf.train.exponential_decay(
- 0.01, # Base learning rate.
- batch * BATCH_SIZE, # Current index into the dataset.
- train_size, # Decay step.
- 0.95, # Decay rate.
- staircase=True)
- # Use simple momentum for the optimization.
- optimizer = tf.train.MomentumOptimizer(learning_rate,
- 0.9).minimize(loss,
- global_step=batch)
- # Predictions for the current training minibatch.
- train_prediction = tf.nn.softmax(logits)
- # Predictions for the test and validation, which we'll compute less often.
- eval_prediction = tf.nn.softmax(model(eval_data))
- # Small utility function to evaluate a dataset by feeding batches of data to
- # {eval_data} and pulling the results from {eval_predictions}.
- # Saves memory and enables this to run on smaller GPUs.
- def eval_in_batches(data, sess):
- """Get all predictions for a dataset by running it in small batches."""
- size = data.shape[0]
- if size < EVAL_BATCH_SIZE:
- raise ValueError("batch size for evals larger than dataset: %d" % size)
- predictions = numpy.ndarray(shape=(size, NUM_LABELS), dtype=numpy.float32)
- for begin in range(0, size, EVAL_BATCH_SIZE):
- end = begin + EVAL_BATCH_SIZE
- if end <= size:
- predictions[begin:end, :] = sess.run(
- eval_prediction,
- feed_dict={eval_data: data[begin:end, ...]})
- else:
- batch_predictions = sess.run(
- eval_prediction,
- feed_dict={eval_data: data[-EVAL_BATCH_SIZE:, ...]})
- predictions[begin:, :] = batch_predictions[begin - size:, :]
- return predictions
- # Create a local session to run the training.
- start_time = time.time()
- with tf.Session() as sess:
- # Run all the initializers to prepare the trainable parameters.
- tf.global_variables_initializer().run()
- print('Initialized!')
- # Loop through training steps.
- for step in range(int(num_epochs * train_size) // BATCH_SIZE):
- # Compute the offset of the current minibatch in the data.
- # Note that we could use better randomization across epochs.
- offset = (step * BATCH_SIZE) % (train_size - BATCH_SIZE)
- batch_data = train_data[offset:(offset + BATCH_SIZE), ...]
- batch_labels = train_labels[offset:(offset + BATCH_SIZE)]
- # This dictionary maps the batch data (as a numpy array) to the
- # node in the graph it should be fed to.
- feed_dict = {train_data_node: batch_data, train_labels_node: batch_labels}
- # Run the optimizer to update weights.
- sess.run(optimizer, feed_dict=feed_dict)
- # print some extra information once reach the evaluation frequency
- if step % EVAL_FREQUENCY == 0:
- # fetch some extra nodes' data
- l, lr, predictions = sess.run([loss, learning_rate, train_prediction], feed_dict=feed_dict)
- elapsed_time = time.time() - start_time
- start_time = time.time()
- print('Step %d (epoch %.2f), %.1f ms' %
- (step, float(step) * BATCH_SIZE / train_size,
- 1000 * elapsed_time / EVAL_FREQUENCY))
- print('Minibatch loss: %.3f, learning rate: %.6f' % (l, lr))
- print('Minibatch error: %.1f%%' % error_rate(predictions, batch_labels))
- print('Validation error: %.1f%%' % error_rate(eval_in_batches(validation_data, sess), validation_labels))
- sys.stdout.flush()
- # Finally print the result!
- test_error = error_rate(eval_in_batches(test_data, sess), test_labels)
- print('Test error: %.1f%%' % test_error)
- if FLAGS.self_test:
- print('test_error', test_error)
- assert test_error == 0.0, 'expected 0.0 test_error, got %.2f' % (test_error,)
- if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument(
- '--use_fp16',
- default=False,
- help='Use half floats instead of full floats if True.',
- action='store_true')
- parser.add_argument(
- '--self_test',
- default=False,
- action='store_true',
- help='True if running a self test.')
- FLAGS, unparsed = parser.parse_known_args()
- tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
网址里面还有很多其它的示例,这些示例代码是最全的,比google网站上的还全,也比 github 上最新的 tensorflow 的库的例子要全要好 。
tensorflow 的 tutorial 的卷积神经网络的例子 convolutional.py的更多相关文章
- 使用TensorFlow v2.0构建卷积神经网络
使用TensorFlow v2.0构建卷积神经网络. 这个例子使用低级方法来更好地理解构建卷积神经网络和训练过程背后的所有机制. CNN 概述 MNIST 数据集概述 此示例使用手写数字的MNIST数 ...
- 【深度学习与TensorFlow 2.0】卷积神经网络(CNN)
注:在很长一段时间,MNIST数据集都是机器学习界很多分类算法的benchmark.初学深度学习,在这个数据集上训练一个有效的卷积神经网络就相当于学习编程的时候打印出一行“Hello World!”. ...
- TensorFlow 深度学习笔记 卷积神经网络
Convolutional Networks 转载请注明作者:梦里风林 Github工程地址:https://github.com/ahangchen/GDLnotes 欢迎star,有问题可以到Is ...
- TensorFlow 实战之实现卷积神经网络
本文根据最近学习TensorFlow书籍网络文章的情况,特将一些学习心得做了总结,详情如下.如有不当之处,请各位大拿多多指点,在此谢过. 一.相关性概念 1.卷积神经网络(ConvolutionNeu ...
- 机器学习与Tensorflow(4)——卷积神经网络与tensorflow实现
1.标准卷积神经网络 标准的卷积神经网络由输入层.卷积层(convolutional layer).下采样层(downsampling layer).全连接层(fully—connected laye ...
- tensorflow学习笔记七----------卷积神经网络
卷积神经网络比神经网络稍微复杂一些,因为其多了一个卷积层(convolutional layer)和池化层(pooling layer). 使用mnist数据集,n个数据,每个数据的像素为28*28* ...
- tensorflow学习之路-----卷积神经网络个人总结
卷积神经网络大总结(个人理解) 神经网络 1.概念:从功能他们模仿真实数据 2.结构:输入层.隐藏层.输出层.其中隐藏层要有的参数:权重.偏置.激励函数.过拟合 3.功能:能通过模仿,从而学到事件 其 ...
- tensorflow文本分类实战——卷积神经网络CNN
首先说明使用的工具和环境:python3.6.8 tensorflow1.14.0 centos7.0(最好用Ubuntu) 关于环境的搭建只做简单说明,我这边是使用pip搭建了python的 ...
- Tensorflow学习教程------利用卷积神经网络对mnist数据集进行分类_利用训练好的模型进行分类
#coding:utf-8 import tensorflow as tf from PIL import Image,ImageFilter from tensorflow.examples.tut ...
随机推荐
- PHP从千千静听服务器获取lrc歌词
<?php //转载请注明出处 uenucom function SingleDecToHex($dec) { $tmp=""; $dec=$dec%16; if($ ...
- VM下redhat9.0不能上网
近期本人在学习linux时,安装Red Hat Linux9后,可是上不了网,弄得查资料还得切换到虚拟机上去,特耗时间.还好没有疯掉! 首先,测试下你的linux看是否是这类问题,输入ping www ...
- C#中的事件介绍
什么是事件?事件有哪些?怎么用事件? 一.什么是事件? 事件(Event) 基本上说是一个用户操作,如按键.点击.鼠标移动.输入值改变等等,或者是一些出现,如系统生成的通知.应用程序需要在事件发生时响 ...
- a5调试
1 generating rsa key...[ 4.452000] mmc0: error -110 whilst initialising SD card[ 5.602000] mmc ...
- 开发高性能的MongoDB应用—浅谈MongoDB性能优化
关联文章索引: 大数据时代的数据存储,非关系型数据库MongoDB 性能与用户量 “如何能让软件拥有更高的性能?”,我想这是一个大部分开发者都思考过的问题.性能往往决定了一个软件的质量,如果你开发的是 ...
- easy UI树形复选框
首先,展示一下结果 这个是使用easyui的combotree控件来实现的,具体的代码如下: 1,声明一个复选框 <select id="rolePer" name=&quo ...
- vb 定时执行php程序
托盘模块 Option Explicit Public Const NIF_ICON = &H2 Public Const NIF_MESSAGE = &H1 Public Const ...
- 第一百四十六节,JavaScript,百度分享保持居中--下拉菜单
JavaScript,百度分享保持居中--下拉菜单 百度分享保持居中 效果图 html代码 <div id="share"> <h2>分享到</h2& ...
- 【python】获取网页中中文内容并分词
# -*- coding: utf-8 -*- import urllib2 import re import time import jieba url="http://www.baidu ...
- .NET中的枚举用法浅析
本文简单分析了.NET中的枚举用法.分享给大家供大家参考.具体分析如下: 我理解的枚举就是编程中约定的一个“可选值”:例如QQ的在线状态,分别有 在线,Q我吧,隐身,忙碌等等...我觉得这就是一 ...