• 基于tensorflow使用CNN识别MNIST

  • 参数数量：第一个卷积层5x5x1x32=800个参数，第二个卷积层5x5x32x64=51200个参数，第三个全连接层7x7x64x1024=3211264个参数，第四个输出层1024x10=10240个参数，总量级为330万个参数，单机训练时间约为30分钟。

  • 关于优化算法：随机梯度下降法的learning rate需要逐渐变小，因为随机抽取样本引入了噪音，使得我们在最小点处的随机梯度仍然不为0。对于batch gradient descent不存在这个问题，在最小点损失函数的梯度变为0，因此batch gradient descent可以使用固定的learning rate。为了让learning rate逐渐变小，有以下几种变种算法。

  • Momentum algorithm accumulates an exponentially decaying moving average of past gradients and continues to move in their direction.
  • AdaGrad adapts the learning rates of all model parameters by scaling them inversely proportional to the square root of the sum of all their historical squared values. But the accumulation of squared gradients from the beginning of training can result in a premature and excessive decrease in the effective learning rate.
  • RMSProp： AdaGrad is designed to converge rapidly when applied to a convex function. When applied to a non-convex function to train a neural network, the learning trajectory may pass through many different structures and eventually arrive at a region that is a locally convex bowl. AdaGrad shrinks the learning rate according to the entire history of the squared gradient and may have made the learning rate too small before arriving at such a convex structure.RMSProp uses an exponentially decaying average to discard history from the extreme past so that it can converge rapidly after finding a convex bowl, as if it were an instance of the AdaGrad algorithm initialized within that bowl.
  • Adam：The name “Adam” derives from the phrase “adaptive moments.” It is a variant on the combination of RMSProp and momentum with a few important distinctions. Adam is generally regarded as being fairly robust to the choice of hyperparameters, though the learning rate sometimes needs to be changed from the suggested default.
  • 如果将MNIST数据集的AdamOptimizer换成GradientDescentOptimizer，测试集的准确率为0.9296.

官方demo



"""A deep MNIST classifier using convolutional layers.

See extensive documentation at

https://www.tensorflow.org/get_started/mnist/pros

"""

# Disable linter warnings to maintain consistency with tutorial.

# pylint: disable=invalid-name

# pylint: disable=g-bad-import-order

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import argparse

import sys

import tempfile

from tensorflow.examples.tutorials.mnist import input_data

import tensorflow as tf

FLAGS = None

def deepnn(x):

  """deepnn builds the graph for a deep net for classifying digits.

  Args:

    x: an input tensor with the dimensions (N_examples, 784), where 784 is the

    number of pixels in a standard MNIST image.

  Returns:

    A tuple (y, keep_prob). y is a tensor of shape (N_examples, 10), with values

    equal to the logits of classifying the digit into one of 10 classes (the

    digits 0-9). keep_prob is a scalar placeholder for the probability of

    dropout.

  """

  # Reshape to use within a convolutional neural net.

  # Last dimension is for "features" - there is only one here, since images are

  # grayscale -- it would be 3 for an RGB image, 4 for RGBA, etc.

  with tf.name_scope('reshape'):

    x_image = tf.reshape(x, [-1, 28, 28, 1])

  # First convolutional layer - maps one grayscale image to 32 feature maps.

  with tf.name_scope('conv1'):

    W_conv1 = weight_variable([5, 5, 1, 32])

    b_conv1 = bias_variable([32])

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

  # Pooling layer - downsamples by 2X.

  with tf.name_scope('pool1'):

    h_pool1 = max_pool_2x2(h_conv1)

  # Second convolutional layer -- maps 32 feature maps to 64.

  with tf.name_scope('conv2'):

    W_conv2 = weight_variable([5, 5, 32, 64])

    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

  # Second pooling layer.

  with tf.name_scope('pool2'):

    h_pool2 = max_pool_2x2(h_conv2)

  # Fully connected layer 1 -- after 2 round of downsampling, our 28x28 image

  # is down to 7x7x64 feature maps -- maps this to 1024 features.

  with tf.name_scope('fc1'):

    W_fc1 = weight_variable([7 * 7 * 64, 1024])

    b_fc1 = bias_variable([1024])

    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

  # Dropout - controls the complexity of the model, prevents co-adaptation of

  # features.

  with tf.name_scope('dropout'):

    keep_prob = tf.placeholder(tf.float32)

    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

  # Map the 1024 features to 10 classes, one for each digit

  with tf.name_scope('fc2'):

    W_fc2 = weight_variable([1024, 10])

    b_fc2 = bias_variable([10])

    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

  return y_conv, keep_prob

def conv2d(x, W):

  """conv2d returns a 2d convolution layer with full stride."""

  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):

  """max_pool_2x2 downsamples a feature map by 2X."""

  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],

                        strides=[1, 2, 2, 1], padding='SAME')

def weight_variable(shape):

  """weight_variable generates a weight variable of a given shape."""

  initial = tf.truncated_normal(shape, stddev=0.1)

  return tf.Variable(initial)

def bias_variable(shape):

  """bias_variable generates a bias variable of a given shape."""

  initial = tf.constant(0.1, shape=shape)

  return tf.Variable(initial)

def main(_):

  # Import data

  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)

  # Create the model

  x = tf.placeholder(tf.float32, [None, 784])

  # Define loss and optimizer

  y_ = tf.placeholder(tf.float32, [None, 10])

  # Build the graph for the deep net

  y_conv, keep_prob = deepnn(x)

  with tf.name_scope('loss'):

    cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_,

                                                            logits=y_conv)

  cross_entropy = tf.reduce_mean(cross_entropy)

  with tf.name_scope('adam_optimizer'):

    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

  with tf.name_scope('accuracy'):

    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))

    correct_prediction = tf.cast(correct_prediction, tf.float32)

  accuracy = tf.reduce_mean(correct_prediction)

  graph_location = tempfile.mkdtemp()

  print('Saving graph to: %s' % graph_location)

  train_writer = tf.summary.FileWriter(graph_location)

  train_writer.add_graph(tf.get_default_graph())

  with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())

    for i in range(20000):

      batch = mnist.train.next_batch(50)

      if i % 100 == 0:

        train_accuracy = accuracy.eval(feed_dict={

            x: batch[0], y_: batch[1], keep_prob: 1.0})

        print('step %d, training accuracy %g' % (i, train_accuracy))

      train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

    print('test accuracy %g' % accuracy.eval(feed_dict={

        x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

if __name__ == '__main__':

  parser = argparse.ArgumentParser()

  parser.add_argument('--data_dir', type=str,

                      default='/tmp/tensorflow/mnist/input_data',

                      help='Directory for storing input data')

  FLAGS, unparsed = parser.parse_known_args()

  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

reuslt

"D:\Program Files\Anaconda3\python.exe" "D:\Program Files\JetBrains\PyCharm Community Edition 2017.2.2\helpers\pydev\pydevd.py" --multiproc --qt-support=auto --client 127.0.0.1 --port 1541 --file F:/RANJIEWEN/Deep_learning/TensorFlow/基于MNIST数据的卷积神经网络CNN.py

pydev debugger: process 3288 is connecting

Connected to pydev debugger (build 172.3757.67)

Start processing MNIST handwritten digits data...

Start evaluating CNN model by tensorflow...

WARNING:tensorflow:From D:\Program Files\Anaconda3\lib\site-packages\tensorflow\python\util\tf_should_use.py:175: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.

Instructions for updating:

Use `tf.global_variables_initializer` instead.

2017-09-08 16:50:19.814600: W C:\tf_jenkins\home\workspace\rel-win\M\windows\PY\35\tensorflow\core\platform\cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX instructions, but these are available on your machine and could speed up CPU computations.

2017-09-08 16:50:19.814600: W C:\tf_jenkins\home\workspace\rel-win\M\windows\PY\35\tensorflow\core\platform\cpu_feature_guard.cc:45] The TensorFlow library wasn't compiled to use AVX2 instructions, but these are available on your machine and could speed up CPU computations.

step 0, training accuracy 0.06

step 100, training accuracy 0.9

step 200, training accuracy 0.78

step 300, training accuracy 0.9

step 400, training accuracy 0.92

step 500, training accuracy 0.98

step 600, training accuracy 0.94

step 700, training accuracy 0.94

step 800, training accuracy 1

step 900, training accuracy 0.96

step 1000, training accuracy 0.96

step 1100, training accuracy 0.98

step 1200, training accuracy 0.98

step 1300, training accuracy 0.98

step 1400, training accuracy 0.94

step 1500, training accuracy 0.96

step 1600, training accuracy 1

step 1700, training accuracy 0.98

step 1800, training accuracy 0.98

step 1900, training accuracy 0.98

step 2000, training accuracy 0.96

step 2100, training accuracy 1

step 2200, training accuracy 1

step 2300, training accuracy 0.94

step 2400, training accuracy 1

step 2500, training accuracy 0.96

step 2600, training accuracy 0.98

step 2700, training accuracy 0.98

step 2800, training accuracy 0.98

step 2900, training accuracy 1

step 3000, training accuracy 1

step 3100, training accuracy 0.98

step 3200, training accuracy 0.96

step 3300, training accuracy 1

step 3400, training accuracy 1

step 3500, training accuracy 0.96

step 3600, training accuracy 1

step 3700, training accuracy 0.98

step 3800, training accuracy 1

step 3900, training accuracy 0.98

step 4000, training accuracy 0.96

step 4100, training accuracy 0.96

step 4200, training accuracy 1

step 4300, training accuracy 0.96

step 4400, training accuracy 1

step 4500, training accuracy 1

step 4600, training accuracy 1

step 4700, training accuracy 1

step 4800, training accuracy 0.98

step 4900, training accuracy 0.96

step 5000, training accuracy 1

step 5100, training accuracy 0.98

step 5200, training accuracy 1

step 5300, training accuracy 0.98

step 5400, training accuracy 0.96

step 5500, training accuracy 0.98

step 5600, training accuracy 1

step 5700, training accuracy 1

step 5800, training accuracy 1

step 5900, training accuracy 0.98

step 6000, training accuracy 1

step 6100, training accuracy 1

step 6200, training accuracy 1

step 6300, training accuracy 1

step 6400, training accuracy 1

step 6500, training accuracy 1

step 6600, training accuracy 1

step 6700, training accuracy 0.96

step 6800, training accuracy 1

step 6900, training accuracy 1

step 7000, training accuracy 1

step 7100, training accuracy 1

step 7200, training accuracy 1

step 7300, training accuracy 1

step 7400, training accuracy 1

step 7500, training accuracy 1

step 7600, training accuracy 1

step 7700, training accuracy 1

step 7800, training accuracy 0.96

step 7900, training accuracy 1

step 8000, training accuracy 1

step 8100, training accuracy 1

step 8200, training accuracy 0.98

step 8300, training accuracy 0.98

step 8400, training accuracy 1

step 8500, training accuracy 1

step 8600, training accuracy 1

step 8700, training accuracy 1

step 8800, training accuracy 0.98

step 8900, training accuracy 1

step 9000, training accuracy 1

step 9100, training accuracy 1

step 9200, training accuracy 1

step 9300, training accuracy 0.98

step 9400, training accuracy 1

step 9500, training accuracy 0.98

step 9600, training accuracy 1

step 9700, training accuracy 1

step 9800, training accuracy 1

step 9900, training accuracy 1

step 10000, training accuracy 1

step 10100, training accuracy 1

step 10200, training accuracy 1

step 10300, training accuracy 0.98

step 10400, training accuracy 1

step 10500, training accuracy 1

step 10600, training accuracy 1

step 10700, training accuracy 1

step 10800, training accuracy 1

step 10900, training accuracy 1

step 11000, training accuracy 1

step 11100, training accuracy 1

step 11200, training accuracy 1

step 11300, training accuracy 0.98

step 11400, training accuracy 1

step 11500, training accuracy 1

step 11600, training accuracy 1

step 11700, training accuracy 1

step 11800, training accuracy 1

step 11900, training accuracy 1

step 12000, training accuracy 1

step 12100, training accuracy 1

step 12200, training accuracy 0.98

step 12300, training accuracy 1

step 12400, training accuracy 1

step 12500, training accuracy 1

step 12600, training accuracy 1

step 12700, training accuracy 1

step 12800, training accuracy 1

step 12900, training accuracy 1

step 13000, training accuracy 1

step 13100, training accuracy 1

step 13200, training accuracy 1

step 13300, training accuracy 1

step 13400, training accuracy 1

step 13500, training accuracy 1

step 13600, training accuracy 1

step 13700, training accuracy 1

step 13800, training accuracy 1

step 13900, training accuracy 1

step 14000, training accuracy 1

step 14100, training accuracy 1

step 14200, training accuracy 1

step 14300, training accuracy 1

step 14400, training accuracy 1

step 14500, training accuracy 1

step 14600, training accuracy 1

step 14700, training accuracy 1

step 14800, training accuracy 1

step 14900, training accuracy 1

step 15000, training accuracy 1

step 15100, training accuracy 1

step 15200, training accuracy 1

step 15300, training accuracy 1

step 15400, training accuracy 1

step 15500, training accuracy 0.98

step 15600, training accuracy 1

step 15700, training accuracy 1

step 15800, training accuracy 1

step 15900, training accuracy 1

step 16000, training accuracy 1

step 16100, training accuracy 1

step 16200, training accuracy 1

step 16300, training accuracy 1

step 16400, training accuracy 1

step 16500, training accuracy 1

step 16600, training accuracy 1

step 16700, training accuracy 1

step 16800, training accuracy 1

step 16900, training accuracy 1

step 17000, training accuracy 1

step 17100, training accuracy 1

step 17200, training accuracy 1

step 17300, training accuracy 1

step 17400, training accuracy 0.98

step 17500, training accuracy 1

step 17600, training accuracy 1

step 17700, training accuracy 1

step 17800, training accuracy 1

step 17900, training accuracy 1

step 18000, training accuracy 1

step 18100, training accuracy 1

step 18200, training accuracy 1

step 18300, training accuracy 1

step 18400, training accuracy 1

step 18500, training accuracy 1

step 18600, training accuracy 1

step 18700, training accuracy 1

step 18800, training accuracy 1

step 18900, training accuracy 1

step 19000, training accuracy 1

step 19100, training accuracy 1

step 19200, training accuracy 1

step 19300, training accuracy 1

step 19400, training accuracy 1

step 19500, training accuracy 1

step 19600, training accuracy 1

step 19700, training accuracy 1

step 19800, training accuracy 1

step 19900, training accuracy 1

test accuracy 0.9923

Process finished with exit code 1
  • 最后19900次迭代完成后，会消耗大量内存，8G都会卡死。。。

参考dmeo

# -*- coding: utf-8 -*-

"""

Created on Thu Sep  7 11:06:36 2017

@author: Administrator

"""

# @description: implement a CNN model upon MNIST handwritten digits

# @ref: http://yann.lecun.com/exdb/mnist/

import gzip

import struct

import numpy as np

from sklearn import preprocessing

import tensorflow as tf

# MNIST data is stored in binary format,

# and we transform them into numpy ndarray objects by the following two utility functions

def read_image(file_name):

    with gzip.open(file_name, 'rb') as f:

        buf = f.read()

        index = 0

        magic, images, rows, columns = struct.unpack_from('>IIII' , buf , index)

        index += struct.calcsize('>IIII')

        image_size = '>' + str(images*rows*columns) + 'B'

        ims = struct.unpack_from(image_size, buf, index)

        im_array = np.array(ims).reshape(images, rows, columns)

        return im_array

def read_label(file_name):

    with gzip.open(file_name, 'rb') as f:

        buf = f.read()

        index = 0

        magic, labels = struct.unpack_from('>II', buf, index)

        index += struct.calcsize('>II')

        label_size = '>' + str(labels) + 'B'

        labels = struct.unpack_from(label_size, buf, index)

        label_array = np.array(labels)

        return label_array

print ("Start processing MNIST handwritten digits data...")

train_x_data = read_image("MNIST_data/train-images-idx3-ubyte.gz")  # shape: 60000x28x28

train_x_data = train_x_data.reshape(train_x_data.shape[0], train_x_data.shape[1], train_x_data.shape[2], 1).astype(np.float32)

train_y_data = read_label("MNIST_data/train-labels-idx1-ubyte.gz")

test_x_data = read_image("MNIST_data/t10k-images-idx3-ubyte.gz")  # shape: 10000x28x28

test_x_data = test_x_data.reshape(test_x_data.shape[0], test_x_data.shape[1], test_x_data.shape[2], 1).astype(np.float32)

test_y_data = read_label("MNIST_data/t10k-labels-idx1-ubyte.gz")

train_x_minmax = train_x_data / 255.0

test_x_minmax = test_x_data / 255.0

# Of course you can also use the utility function to read in MNIST provided by tensorflow

# from tensorflow.examples.tutorials.mnist import input_data

# mnist = input_data.read_data_sets("MNIST_data/", one_hot=False)

# train_x_minmax = mnist.train.images

# train_y_data = mnist.train.labels

# test_x_minmax = mnist.test.images

# test_y_data = mnist.test.labels

# Reformat y into one-hot encoding style

lb = preprocessing.LabelBinarizer()

lb.fit(train_y_data)

train_y_data_trans = lb.transform(train_y_data)

test_y_data_trans = lb.transform(test_y_data)

print ("Start evaluating CNN model by tensorflow...")

# Model input

x = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])

y_ = tf.placeholder(tf.float32, [None, 10])

# Weight initialization

def weight_variable(shape):

    initial = tf.truncated_normal(shape, stddev=0.1)

    return tf.Variable(initial)

def bias_variable(shape):

    initial = tf.constant(0.1, shape=shape)

    return tf.Variable(initial)

# Convolution and Pooling

def conv2d(x, W):

    # `tf.nn.conv2d()` computes a 2-D convolution given 4-D `input` and `filter` tensors

    # input tensor shape `[batch, in_height, in_width, in_channels]`, batch is number of observation

    # filter tensor shape `[filter_height, filter_width, in_channels, out_channels]`

    # strides: the stride of the sliding window for each dimension of input.

    # padding: 'SAME' or 'VALID', determine the type of padding algorithm to use

    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):

    # `tf.nn.max_pool` performs the max pooling on the input

    #  ksize: the size of the window for each dimension of the input tensor.

    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

# First convolutional layer

# Convolution: compute 32 features for each 5x5 patch

# Max pooling: reduce image size to 14x14.

W_conv1 = weight_variable([5, 5, 1, 32])

b_conv1 = bias_variable([32])

h_conv1 = tf.nn.relu(conv2d(x,  W_conv1) + b_conv1)

h_pool1 = max_pool_2x2(h_conv1)

# Second convolutional layer

# Convolution: compute 64 features for each 5x5 patch

# Max pooling: reduce image size to 7x7

W_conv2 = weight_variable([5, 5, 32, 64])

b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)

h_pool2 = max_pool_2x2(h_conv2)

# Densely connected layer

# Fully-conected layer with 1024 neurons

W_fc1 = weight_variable([7 * 7 * 64, 1024])

b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])

h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

# Dropout

# To reduce overfitting, we apply dropout before the readout layer.

keep_prob = tf.placeholder(tf.float32)

h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

# Readout layer

W_fc2 = weight_variable([1024, 10])

b_fc2 = bias_variable([10])

y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

# Train and evaluate

loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv,labels= y_)) #

# y = tf.nn.softmax(y_conv)

# loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

optimizer = tf.train.AdamOptimizer(1e-4)

# optimizer = tf.train.GradientDescentOptimizer(1e-4)

train = optimizer.minimize(loss)

correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init = tf.initialize_all_variables()

sess = tf.Session()

sess.run(init)

for step in range(20000):

    sample_index = np.random.choice(train_x_minmax.shape[0], 50)

    batch_xs = train_x_minmax[sample_index, :]

    batch_ys = train_y_data_trans[sample_index, :]

    if step % 100 == 0:

        train_accuracy = sess.run(accuracy, feed_dict={

            x: batch_xs, y_: batch_ys, keep_prob: 1.0})

        print ("step %d, training accuracy %g" % (step, train_accuracy))

    sess.run(train, feed_dict={x: batch_xs, y_: batch_ys, keep_prob: 0.5})

print ("test accuracy %g" % sess.run(accuracy, feed_dict={

    x: test_x_minmax, y_: test_y_data_trans, keep_prob: 1.0}))

基于MNIST数据的卷积神经网络CNN的更多相关文章

  1. 卷积神经网络CNN原理以及TensorFlow实现

    在知乎上看到一段介绍卷积神经网络的文章,感觉讲的特别直观明了,我整理了一下.首先介绍原理部分. [透析] 卷积神经网络CNN究竟是怎样一步一步工作的? 通过一个图像分类问题介绍卷积神经网络是如何工作的 ...

  2. TensorFlow 2.0 深度学习实战 —— 浅谈卷积神经网络 CNN

    前言 上一章为大家介绍过深度学习的基础和多层感知机 MLP 的应用,本章开始将深入讲解卷积神经网络的实用场景.卷积神经网络 CNN(Convolutional Neural Networks,Conv ...

  3. 【深度学习系列】手写数字识别卷积神经--卷积神经网络CNN原理详解(一)

    上篇文章我们给出了用paddlepaddle来做手写数字识别的示例,并对网络结构进行到了调整,提高了识别的精度.有的同学表示不是很理解原理,为什么传统的机器学习算法,简单的神经网络(如多层感知机)都可 ...

  4. 深度学习之卷积神经网络(CNN)详解与代码实现（二）

    用Tensorflow实现卷积神经网络(CNN) 本文系作者原创,转载请注明出处:https://www.cnblogs.com/further-further-further/p/10737065. ...

  5. 【深度学习系列】卷积神经网络CNN原理详解(一)——基本原理

    上篇文章我们给出了用paddlepaddle来做手写数字识别的示例,并对网络结构进行到了调整,提高了识别的精度.有的同学表示不是很理解原理,为什么传统的机器学习算法,简单的神经网络(如多层感知机)都可 ...

  6. 卷积神经网络(CNN)学习笔记1：基础入门

    卷积神经网络(CNN)学习笔记1:基础入门 Posted on 2016-03-01   |   In Machine Learning  |   9 Comments  |   14935  Vie ...

  7. 基于MTCNN多任务级联卷积神经网络进行的人脸识别 世纪晟人脸检测

    神经网络和深度学习目前为处理图像识别的许多问题提供了最佳解决方案,而基于MTCNN(多任务级联卷积神经网络)的人脸检测算法也解决了传统算法对环境要求高.人脸要求高.检测耗时高的弊端. 基于MTCNN多 ...

  8. MNIST数据集上卷积神经网络的简单实现（使用PyTorch)

    设计的CNN模型包括一个输入层,输入的是MNIST数据集中28*28*1的灰度图 两个卷积层, 第一层卷积层使用6个3*3的kernel进行filter,步长为1,填充1.这样得到的尺寸是(28+1* ...

  9. python机器学习卷积神经网络(CNN)

    卷积神经网络(CNN) 关注公众号"轻松学编程"了解更多. 一.简介 ​ 卷积神经网络(Convolutional Neural Network,CNN)是一种前馈神经网络,它的人 ...

随机推荐

  1. LeetCode（90） Subsets II

    题目 Given a collection of integers that might contain duplicates, nums, return all possible subsets. ...

  2. Android AAR 混淆的坑

    一定不要忘记加上这段 -keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,A ...

  3. C# 反射总结

    反射(Reflection)是.NET中的重要机制,通过放射,可以在运行时获得.NET中每一个类型(包括类.结构.委托.接口和枚举等)的成员,包括方法.属性.事件,以及构造函数等.还可以获得每个成员的 ...

  4. C/C++的类型安全

    类型安全很大程度上可以等价于内存安全,类型安全的代码不会试图访问自己没被授权的内存区域.“类型安全”常被用来形容编程语言,其根据在于该门编程语言是否提供保障类型安全的机制:有的时候也用“类型安全”形容 ...

  5. HDU-1532 Drainage Ditches，人生第一道网络流！

    Drainage Ditches 自己拉的专题里面没有这题,网上找博客学习网络流的时候看到闯亮学长的博客然后看到这个网络流入门题!随手一敲WA了几发看讨论区才发现坑点! 本题采用的是Edmonds-K ...

  6. BZOJ 1095 [ZJOI2007]Hide 捉迷藏 ——动态点分治

    [题目分析] 这题好基啊. 先把分治树搞出来.然后每个节点两个堆. 第一个堆保存这个块里的所有点(即分治树中的所有儿子)到分治树上的父亲的距离. 第二个堆保存分治树子树中所有儿子第一个堆的最大值. 建 ...

  7. BZOJ 3990 [SDOI2015]排序 ——搜索

    [题目分析] 可以发现,操作的先后顺序是不影响结果的,那么答案就是n!的和. 可以从小的步骤开始搜索,使得每一个当前最小的块都是上升的数列,然后看看是否可行即可. 复杂度好像是4^n [代码](哪里写 ...

  8. BZOJ 3733 [Pa2013]Iloczyn 模拟爆搜

    Description 给定正整数n和k,问能否将n分解为k个不同正整数的乘积 Input 第一行一个数T(T<=4000)表示测试组数 接下来T行每行两个数n(n<=10^9),k(k& ...

  9. poj1930 数论

    Dead Fraction Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 1258   Accepted: 379 Desc ...

  10. nginx的配置文件 【nginx.conf】

    #user nobody; worker_processes 1; #error_log logs/error.log; #error_log logs/error.log notice; #erro ...