卷积神经网络(CNN)的简单介绍及代码实现 - 全文

卷积神经网络(CNN)的基础介绍见，这里主要以代码实现为主。

CNN是一个多层的神经网络，每层由多个二维平面组成，而每个平面由多个独立神经元组成。

以MNIST作为数据库，仿照LeNet-5和tiny-cnn( ) 设计一个简单的7层CNN结构如下：
输入层Input：神经元数量32*32=1024；

C1层：卷积窗大小5*5，输出特征图数量6，卷积窗种类6，输出特征图大小28*28，可训练参数(权值+阈值(偏置))5*5*6+6=150+6，神经元数量28*28*6=4704；

S2层：卷积窗大小2*2，输出下采样图数量6，卷积窗种类6，输出下采样图大小14*14，可训练参数1*6+6=6+6，神经元数量14*14*6=1176；

C3层：卷积窗大小5*5，输出特征图数量16，卷积窗种类6*16=96，输出特征图大小10*10，可训练参数5*5*(6*16)+16=2400+16，神经元数量10*10*16=1600；

S4层：卷积窗大小2*2，输出下采样图数量16，卷积窗种类16，输出下采样图大小5*5，可训练参数1*16+16=16+16，神经元数量5*5*16=400；

C5层：卷积窗大小5*5，输出特征图数量120，卷积窗种类16*120=1920，输出特征图大小1*1，可训练参数5*5*(16*120)+120=48000+120，神经元数量1*1*120=120；

输出层Output：卷积窗大小1*1，输出特征图数量10，卷积窗种类120*10=1200，输出特征图大小1*1，可训练参数1*(120*10)+10=1200+10，神经元数量1*1*10=10。

下面对实现执行过程进行描述说明：

1. 从MNIST数据库中分别获取训练样本和测试样本数据：

(1)、原有MNIST库中图像大小为28*28，这里缩放为32*32，数据值范围为[-1,1]，扩充值均取-1；总共60000个32*32训练样本，10000个32*32测试样本；

(2)、输出层有10个输出节点，在训练阶段，对应位置的节点值设为0.8，其它节点设为-0.8.

2. 初始化权值和阈值(偏置)：权值就是卷积图像，每一个特征图上的神经元共享相同的权值和阈值，特征图的数量等于阈值的个数

(1)、权值采用uniform rand的方法初始化；

(2)、阈值均初始化为0.

3. 前向传播：根据权值和阈值，主要计算每层神经元的值

(1)、输入层：每次输入一个32*32数据。

(2)、C1层：分别用每一个5*5的卷积图像去乘以32*32的图像，获得一个28*28的图像，即对应位置相加再求和，stride长度为1；一共6个5*5的卷积图像，然后对每一个神经元加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

(3)、S2层：对C1中6个28*28的特征图生成6个14*14的下采样图，相邻四个神经元分别进行相加求和，然后乘以一个权值，再求均值即除以4，然后再加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

(4)、C3层：由S2中的6个14*14下采样图生成16个10*10特征图，对于生成的每一个10*10的特征图，是由6个5*5的卷积图像去乘以6个14*14的下采样图，然后对应位置相加求和，然后对每一个神经元加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

(5)、S4层：由C3中16个10*10的特征图生成16个5*5下采样图，相邻四个神经元分别进行相加求和，然后乘以一个权值，再求均值即除以4，然后再加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

(6)、C5层：由S4中16个5*5下采样图生成120个1*1特征图，对于生成的每一个1*1的特征图，是由16个5*5的卷积图像去乘以16个5*5的下采用图，然后相加求和，然后对每一个神经元加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

(7)、输出层：即全连接层，输出层中的每一个神经元均是由C5层中的120个神经元乘以相对应的权值，然后相加求和；然后对每一个神经元加上一个阈值，最后再通过tanh激活函数对每一神经元进行运算得到最终每一个神经元的结果。

4. 反向传播：主要计算每层神经元、权值和阈值的误差，以用来更新权值和阈值

(1)、输出层：计算输出层神经元误差；通过mse损失函数的导数函数和tanh激活函数的导数函数来计算输出层神经元误差。

(2)、C5层：计算C5层神经元误差、输出层权值误差、输出层阈值误差；通过输出层神经元误差乘以输出层权值，求和，结果再乘以C5层神经元的tanh激活函数的导数，获得C5层每一个神经元误差；通过输出层神经元误差乘以C5层神经元获得输出层权值误差；输出层误差即为输出层阈值误差。

(3)、S4层：计算S4层神经元误差、C5层权值误差、C5层阈值误差；通过C5层权值乘以C5层神经元误差，求和，结果再乘以S4层神经元的tanh激活函数的导数，获得S4层每一个神经元误差；通过S4层神经元乘以C5层神经元误差，求和，获得C5层权值误差；C5层神经元误差即为C5层阈值误差。

(4)、C3层：计算C3层神经元误差、S4层权值误差、S4层阈值误差；

(5)、S2层：计算S2层神经元误差、C3层权值误差、C3层阈值误差；

(6)、C1层：计算C1层神经元误差、S2层权值误差、S2层阈值误差；

(7)、输入层：计算C1层权值误差、C1层阈值误差.

代码文件：

CNN.hpp：
#ifndef _CNN_HPP_
#define _CNN_HPP_

#include
#include

namespace ANN {

#define width_image_input_CNN 32 //归一化图像宽
#define height_image_input_CNN 32 //归一化图像高
#define width_image_C1_CNN 28
#define height_image_C1_CNN 28
#define width_image_S2_CNN 14
#define height_image_S2_CNN 14
#define width_image_C3_CNN 10
#define height_image_C3_CNN 10
#define width_image_S4_CNN 5
#define height_image_S4_CNN 5
#define width_image_C5_CNN 1
#define height_image_C5_CNN 1
#define width_image_output_CNN 1
#define height_image_output_CNN 1

#define width_kernel_conv_CNN 5 //卷积核大小
#define height_kernel_conv_CNN 5
#define width_kernel_pooling_CNN 2
#define height_kernel_pooling_CNN 2
#define size_pooling_CNN 2

#define num_map_input_CNN 1 //输入层map个数
#define num_map_C1_CNN 6 //C1层map个数
#define num_map_S2_CNN 6 //S2层map个数
#define num_map_C3_CNN 16 //C3层map个数
#define num_map_S4_CNN 16 //S4层map个数
#define num_map_C5_CNN 120 //C5层map个数
#define num_map_output_CNN 10 //输出层map个数

#define num_patterns_train_CNN 60000 //训练模式对数(总数)
#define num_patterns_test_CNN 10000 //测试模式对数(总数)
#define num_epochs_CNN 100 //最大迭代次数
#define accuracy_rate_CNN 0.985 //要求达到的准确率
#define learning_rate_CNN 0.01 //学习率
#define eps_CNN 1e-8

#define len_weight_C1_CNN 150 //C1层权值数，5*5*6*1=150
#define len_bias_C1_CNN 6 //C1层阈值数，6
#define len_weight_S2_CNN 6 //S2层权值数,1*6=6
#define len_bias_S2_CNN 6 //S2层阈值数,6
#define len_weight_C3_CNN 2400 //C3层权值数，5*5*16*6=2400
#define len_bias_C3_CNN 16 //C3层阈值数,16
#define len_weight_S4_CNN 16 //S4层权值数，1*16=16
#define len_bias_S4_CNN 16 //S4层阈值数，16
#define len_weight_C5_CNN 48000 //C5层权值数，5*5*16*120=48000
#define len_bias_C5_CNN 120 //C5层阈值数，120
#define len_weight_output_CNN 1200 //输出层权值数，120*10=1200
#define len_bias_output_CNN 10 //输出层阈值数，10

#define num_neuron_input_CNN 1024 //输入层神经元数，32*32=1024
#define num_neuron_C1_CNN 4704 //C1层神经元数，28*28*6=4704
#define num_neuron_S2_CNN 1176 //S2层神经元数，14*14*6=1176
#define num_neuron_C3_CNN 1600 //C3层神经元数，10*10*16=1600
#define num_neuron_S4_CNN 400 //S4层神经元数，5*5*16=400
#define num_neuron_C5_CNN 120 //C5层神经元数，1*120=120
#define num_neuron_output_CNN 10 //输出层神经元数，1*10=10

class CNN {
public:
CNN();
~CNN();

void init(); //初始化，分配空间
bool train(); //训练
int predict(const unsigned char* data, int width, int height); //预测
bool readModelFile(const char* name); //读取已训练好的BP model

protected:
typedef std::vector wi_connections;
typedef std::vector wo_connections;
typedef std::vector io_connections;> 16) & 255;
ch4 = (i >> 24) & 255;
return((int)ch1 << 24) + ((int)ch2 << 16) + ((int)ch3 << 8) + ch4;
}

static void readMnistImages(std::string filename, double* data_dst, int num_image)
{
const int width_src_image = 28;
const int height_src_image = 28;
const int x_padding = 2;
const int y_padding = 2;
const double scale_min = -1;
const double scale_max = 1;

std::ifstream file(filename, std::ios::binary);
assert(file.is_open());

int magic_number = 0;
int number_of_images = 0;
int n_rows = 0;
int n_cols = 0;
file.read((char*)&magic_number, sizeof(magic_number));
magic_number = reverseInt(magic_number);
file.read((char*)&number_of_images, sizeof(number_of_images));
number_of_images = reverseInt(number_of_images);
assert(number_of_images == num_image);
file.read((char*)&n_rows, sizeof(n_rows));
n_rows = reverseInt(n_rows);
file.read((char*)&n_cols, sizeof(n_cols));
n_cols = reverseInt(n_cols);
assert(n_rows == height_src_image && n_cols == width_src_image);

int size_single_image = width_image_input_CNN * height_image_input_CNN;

for (int i = 0; i < number_of_images; ++i) {
int addr = size_single_image * i;

for (int r = 0; r < n_rows; ++r) {
for (int c = 0; c < n_cols; ++c) {
unsigned char temp = 0;
file.read((char*)&temp, sizeof(temp));
data_dst[addr + width_image_input_CNN * (r + y_padding) + c + x_padding] = (temp / 255.0) * (scale_max - scale_min) + scale_min;
}
}
}
}

static void readMnistLabels(std::string filename, double* data_dst, int num_image)
{
const double scale_max = 0.8;

std::ifstream file(filename, std::ios::binary);
assert(file.is_open());

int magic_number = 0;
int number_of_images = 0;
file.read((char*)&magic_number, sizeof(magic_number));
magic_number = reverseInt(magic_number);
file.read((char*)&number_of_images, sizeof(number_of_images));
number_of_images = reverseInt(number_of_images);
assert(number_of_images == num_image);

for (int i = 0; i < number_of_images; ++i) {
unsigned char temp = 0;
file.read((char*)&temp, sizeof(temp));
data_dst[i * num_map_output_CNN + temp] = scale_max;
}
}

bool CNN::getSrcData()
{
assert(data_input_train && data_output_train && data_input_test && data_output_test);

std::string filename_train_images = "E:/GitCode/NN_Test/data/train-images.idx3-ubyte";
std::string filename_train_labels = "E:/GitCode/NN_Test/data/train-labels.idx1-ubyte";
readMnistImages(filename_train_images, data_input_train, num_patterns_train_CNN);
readMnistLabels(filename_train_labels, data_output_train, num_patterns_train_CNN);

std::string filename_test_images = "E:/GitCode/NN_Test/data/t10k-images.idx3-ubyte";
std::string filename_test_labels = "E:/GitCode/NN_Test/data/t10k-labels.idx1-ubyte";
readMnistImages(filename_test_images, data_input_test, num_patterns_test_CNN);
readMnistLabels(filename_test_labels, data_output_test, num_patterns_test_CNN);

return true;
}

bool CNN::train()
{
out2wi_S2.clear();
out2bias_S2.clear();
out2wi_S4.clear();
out2bias_S4.clear();
in2wo_C3.clear();
weight2io_C3.clear();
bias2out_C3.clear();
in2wo_C1.clear();
weight2io_C1.clear();
bias2out_C1.clear();

calc_out2wi(width_image_C1_CNN, height_image_C1_CNN, width_image_S2_CNN, height_image_S2_CNN, num_map_S2_CNN, out2wi_S2);
calc_out2bias(width_image_S2_CNN, height_image_S2_CNN, num_map_S2_CNN, out2bias_S2);
calc_out2wi(width_image_C3_CNN, height_image_C3_CNN, width_image_S4_CNN, height_image_S4_CNN, num_map_S4_CNN, out2wi_S4);
calc_out2bias(width_image_S4_CNN, height_image_S4_CNN, num_map_S4_CNN, out2bias_S4);
calc_in2wo(width_image_C3_CNN, height_image_C3_CNN, width_image_S4_CNN, height_image_S4_CNN, num_map_C3_CNN, num_map_S4_CNN, in2wo_C3);
calc_weight2io(width_image_C3_CNN, height_image_C3_CNN, width_image_S4_CNN, height_image_S4_CNN, num_map_C3_CNN, num_map_S4_CNN, weight2io_C3);
calc_bias2out(width_image_C3_CNN, height_image_C3_CNN, width_image_S4_CNN, height_image_S4_CNN, num_map_C3_CNN, num_map_S4_CNN, bias2out_C3);
calc_in2wo(width_image_C1_CNN, height_image_C1_CNN, width_image_S2_CNN, height_image_S2_CNN, num_map_C1_CNN, num_map_C3_CNN, in2wo_C1);
calc_weight2io(width_image_C1_CNN, height_image_C1_CNN, width_image_S2_CNN, height_image_S2_CNN, num_map_C1_CNN, num_map_C3_CNN, weight2io_C1);
calc_bias2out(width_image_C1_CNN, height_image_C1_CNN, width_image_S2_CNN, height_image_S2_CNN, num_map_C1_CNN, num_map_C3_CNN, bias2out_C1);

int iter = 0;
for (iter = 0; iter < num_epochs_CNN; iter++) {
std::cout << "epoch: " << iter + 1;

for (int i = 0; i < num_patterns_train_CNN; i++) {
data_single_image = data_input_train + i * num_neuron_input_CNN;
data_single_label = data_output_train + i * num_neuron_output_CNN;

Forward_C1();
Forward_S2();
Forward_C3();
Forward_S4();
Forward_C5();
Forward_output();

Backward_output();
Backward_C5();
Backward_S4();
Backward_C3();
Backward_S2();
Backward_C1();
Backward_input();

UpdateWeights();
}

double accuracyRate = test();
std::cout << ", accuray rate: " << accuracyRate << std::endl;
if (accuracyRate > accuracy_rate_CNN) {
saveModelFile("E:/GitCode/NN_Test/data/cnn.model");
std::cout << "generate cnn model" << std::endl;
break;
}
}

if (iter == num_epochs_CNN) {
saveModelFile("E:/GitCode/NN_Test/data/cnn.model");
std::cout << "generate cnn model" << std::endl;
}

return true;
}

double CNN::activation_function_tanh(double x)
{
double ep = std::exp(x);
double em = std::exp(-x);

return (ep - em) / (ep + em);
}

double CNN::activation_function_tanh_derivative(double x)
{
return (1.0 - x * x);
}

double CNN::activation_function_identity(double x)
{
return x;
}

double CNN::activation_function_identity_derivative(double x)
{
return 1;
}

double CNN::loss_function_mse(double y, double t)
{
return (y - t) * (y - t) / 2;
}

double CNN::loss_function_mse_derivative(double y, double t)
{
return (y - t);
}

void CNN::loss_function_gradient(const double* y, const double* t, double* dst, int len)
{
for (int i = 0; i < len; i++) {
dst[i] = loss_function_mse_derivative(y[i], t[i]);
}
}

double CNN::dot_product(const double* s1, const double* s2, int len)
{
double result = 0.0;

for (int i = 0; i < len; i++) {
result += s1[i] * s2[i];
}

return result;
}

bool CNN::muladd(const double* src, double c, int len, double* dst)
{
for (int i = 0; i < len; i++) {
dst[i] += (src[i] * c);
}

return true;
}

int CNN::get_index(int x, int y, int channel, int width, int height, int depth)
{
assert(x >= 0 && x < width);
assert(y >= 0 && y < height);
assert(channel >= 0 && channel < depth);
return (height * channel + y) * width + x;
}

void CNN::calc_out2wi(int width_in, int height_in, int width_out, int height_out, int depth_out, std::vector& out2wi)
{
for (int i = 0; i < depth_out; i++) {
int block = width_in * height_in * i;

for (int y = 0; y < height_out; y++) {
for (int x = 0; x < width_out; x++) {
int rows = y * width_kernel_pooling_CNN;
int cols = x * height_kernel_pooling_CNN;

wi_connections wi_connections_;
std::pair pair_;

for (int m = 0; m < width_kernel_pooling_CNN; m++) {
for (int n = 0; n < height_kernel_pooling_CNN; n++) {
pair_.first = i;
pair_.second = (rows + m) * width_in + cols + n + block;
wi_connections_.push_back(pair_);
}
}
out2wi.push_back(wi_connections_);
}
}
}
}

void CNN::calc_out2bias(int width, int height, int depth, std::vector& out2bias)
{
for (int i = 0; i < depth; i++) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
out2bias.push_back(i);
}
}
}
}

void CNN::calc_in2wo(int width_in, int height_in, int width_out, int height_out, int depth_in, int depth_out, std::vector& in2wo)
{
int len = width_in * height_in * depth_in;
in2wo.resize(len);

for (int c = 0; c < depth_in; c++) {
for (int y = 0; y < height_in; y += height_kernel_pooling_CNN) {
for (int x = 0; x < width_in; x += width_kernel_pooling_CNN) {
int dymax = min(size_pooling_CNN, height_in - y);
int dxmax = min(size_pooling_CNN, width_in - x);
int dstx = x / width_kernel_pooling_CNN;
int dsty = y / height_kernel_pooling_CNN;

for (int dy = 0; dy < dymax; dy++) {
for (int dx = 0; dx < dxmax; dx++) {
int index_in = get_index(x + dx, y + dy, c, width_in, height_in, depth_in);
int index_out = get_index(dstx, dsty, c, width_out, height_out, depth_out);

wo_connections wo_connections_;
std::pair pair_;
pair_.first = c;
pair_.second = index_out;
wo_connections_.push_back(pair_);

in2wo[index_in] = wo_connections_;
}
}
}
}
}
}

void CNN::calc_weight2io(int width_in, int height_in, int width_out, int height_out, int depth_in, int depth_out, std::vector& weight2io)
{
int len = depth_in;
weight2io.resize(len);

std::pair pair_;
pair_.first = index_in;
pair_.second = index_out;

weight2io[c].push_back(pair_);
}
}
}
}
}
}

void CNN::calc_bias2out(int width_in, int height_in, int width_out, int height_out, int depth_in, int depth_out, std::vector& bias2out)
{
int len = depth_in;
bias2out.resize(len); max_value) {
max_value = neuron_output[i];
pos = i;
}
}

return pos;
}

bool CNN::readModelFile(const char* name)
{
FILE* fp = fopen(name, "rb");
if (fp == NULL) {
return false;
}

int width_image_input =0;
int height_image_input = 0;
int width_image_C1 = 0;
int height_image_C1 = 0;
int width_image_S2 = 0;
int height_image_S2 = 0;
int width_image_C3 = 0;
int height_image_C3 = 0;
int width_image_S4 = 0;
int height_image_S4 = 0;
int width_image_C5 = 0;
int height_image_C5 = 0;
int width_image_output = 0;
int height_image_output = 0;

int width_kernel_conv = 0;
int height_kernel_conv = 0;
int width_kernel_pooling = 0;
int height_kernel_pooling = 0;

int num_map_input = 0;
int num_map_C1 = 0;
int num_map_S2 = 0;
int num_map_C3 = 0;
int num_map_S4 = 0;
int num_map_C5 = 0;
int num_map_output = 0;

int len_weight_C1 = 0;
int len_bias_C1 = 0;
int len_weight_S2 = 0;
int len_bias_S2 = 0;
int len_weight_C3 = 0;
int len_bias_C3 = 0;
int len_weight_S4 = 0;
int len_bias_S4 = 0;
int len_weight_C5 = 0;
int len_bias_C5 = 0;
int len_weight_output = 0;
int len_bias_output = 0;

int num_neuron_input = 0;
int num_neuron_C1 = 0;
int num_neuron_S2 = 0;
int num_neuron_C3 = 0;
int num_neuron_S4 = 0;
int num_neuron_C5 = 0;
int num_neuron_output = 0;

fread(&width_image_input, sizeof(int), 1, fp);
fread(&height_image_input, sizeof(int), 1, fp);
fread(&width_image_C1, sizeof(int), 1, fp);
fread(&height_image_C1, sizeof(int), 1, fp);
fread(&width_image_S2, sizeof(int), 1, fp);
fread(&height_image_S2, sizeof(int), 1, fp);
fread(&width_image_C3, sizeof(int), 1, fp);
fread(&height_image_C3, sizeof(int), 1, fp);
fread(&width_image_S4, sizeof(int), 1, fp);
fread(&height_image_S4, sizeof(int), 1, fp);
fread(&width_image_C5, sizeof(int), 1, fp);
fread(&height_image_C5, sizeof(int), 1, fp);
fread(&width_image_output, sizeof(int), 1, fp);
fread(&height_image_output, sizeof(int), 1, fp);

fread(&width_kernel_conv, sizeof(int), 1, fp);
fread(&height_kernel_conv, sizeof(int), 1, fp);
fread(&width_kernel_pooling, sizeof(int), 1, fp);
fread(&height_kernel_pooling, sizeof(int), 1, fp);

fread(&num_map_input, sizeof(int), 1, fp);
fread(&num_map_C1, sizeof(int), 1, fp);
fread(&num_map_S2, sizeof(int), 1, fp);
fread(&num_map_C3, sizeof(int), 1, fp);
fread(&num_map_S4, sizeof(int), 1, fp);
fread(&num_map_C5, sizeof(int), 1, fp);
fread(&num_map_output, sizeof(int), 1, fp);

fread(&len_weight_C1, sizeof(int), 1, fp);
fread(&len_bias_C1, sizeof(int), 1, fp);
fread(&len_weight_S2, sizeof(int), 1, fp);
fread(&len_bias_S2, sizeof(int), 1, fp);
fread(&len_weight_C3, sizeof(int), 1, fp);
fread(&len_bias_C3, sizeof(int), 1, fp);
fread(&len_weight_S4, sizeof(int), 1, fp);
fread(&len_bias_S4, sizeof(int), 1, fp);
fread(&len_weight_C5, sizeof(int), 1, fp);
fread(&len_bias_C5, sizeof(int), 1, fp);
fread(&len_weight_output, sizeof(int), 1, fp);
fread(&len_bias_output, sizeof(int), 1, fp);

fread(&num_neuron_input, sizeof(int), 1, fp);
fread(&num_neuron_C1, sizeof(int), 1, fp);
fread(&num_neuron_S2, sizeof(int), 1, fp);
fread(&num_neuron_C3, sizeof(int), 1, fp);
fread(&num_neuron_S4, sizeof(int), 1, fp);
fread(&num_neuron_C5, sizeof(int), 1, fp);
fread(&num_neuron_output, sizeof(int), 1, fp);

fread(weight_C1, sizeof(weight_C1), 1, fp);
fread(bias_C1, sizeof(bias_C1), 1, fp);
fread(weight_S2, sizeof(weight_S2), 1, fp);
fread(bias_S2, sizeof(bias_S2), 1, fp);
fread(weight_C3, sizeof(weight_C3), 1, fp);
fread(bias_C3, sizeof(bias_C3), 1, fp);
fread(weight_S4, sizeof(weight_S4), 1, fp);
fread(bias_S4, sizeof(bias_S4), 1, fp);
fread(weight_C5, sizeof(weight_C5), 1, fp);
fread(bias_C5, sizeof(bias_C5), 1, fp);
fread(weight_output, sizeof(weight_output), 1, fp);
fread(bias_output, sizeof(bias_output), 1, fp);

fflush(fp);
fclose(fp);

out2wi_S2.clear();
out2bias_S2.clear();
out2wi_S4.clear();
out2bias_S4.clear();

return true;
}

bool CNN::saveModelFile(const char* name)
{
FILE* fp = fopen(name, "wb");
if (fp == NULL) {
return false;
}

int width_image_input = width_image_input_CNN;
int height_image_input = height_image_input_CNN;
int width_image_C1 = width_image_C1_CNN;
int height_image_C1 = height_image_C1_CNN;
int width_image_S2 = width_image_S2_CNN;
int height_image_S2 = height_image_S2_CNN;
int width_image_C3 = width_image_C3_CNN;
int height_image_C3 = height_image_C3_CNN;
int width_image_S4 = width_image_S4_CNN;
int height_image_S4 = height_image_S4_CNN;
int width_image_C5 = width_image_C5_CNN;
int height_image_C5 = height_image_C5_CNN;
int width_image_output = width_image_output_CNN;
int height_image_output = height_image_output_CNN;

int width_kernel_conv = width_kernel_conv_CNN;
int height_kernel_conv = height_kernel_conv_CNN;
int width_kernel_pooling = width_kernel_pooling_CNN;
int height_kernel_pooling = height_kernel_pooling_CNN;

int num_map_input = num_map_input_CNN;
int num_map_C1 = num_map_C1_CNN;
int num_map_S2 = num_map_S2_CNN;
int num_map_C3 = num_map_C3_CNN;
int num_map_S4 = num_map_S4_CNN;
int num_map_C5 = num_map_C5_CNN;
int num_map_output = num_map_output_CNN;

int len_weight_C1 = len_weight_C1_CNN;
int len_bias_C1 = len_bias_C1_CNN;
int len_weight_S2 = len_weight_S2_CNN;
int len_bias_S2 = len_bias_S2_CNN;
int len_weight_C3 = len_weight_C3_CNN;
int len_bias_C3 = len_bias_C3_CNN;
int len_weight_S4 = len_weight_S4_CNN;
int len_bias_S4 = len_bias_S4_CNN;
int len_weight_C5 = len_weight_C5_CNN;
int len_bias_C5 = len_bias_C5_CNN;
int len_weight_output = len_weight_output_CNN;
int len_bias_output = len_bias_output_CNN;

int num_neuron_input = num_neuron_input_CNN;
int num_neuron_C1 = num_neuron_C1_CNN;
int num_neuron_S2 = num_neuron_S2_CNN;
int num_neuron_C3 = num_neuron_C3_CNN;
int num_neuron_S4 = num_neuron_S4_CNN;
int num_neuron_C5 = num_neuron_C5_CNN;
int num_neuron_output = num_neuron_output_CNN;

fwrite(&width_image_input, sizeof(int), 1, fp);
fwrite(&height_image_input, sizeof(int), 1, fp);
fwrite(&width_image_C1, sizeof(int), 1, fp);
fwrite(&height_image_C1, sizeof(int), 1, fp);
fwrite(&width_image_S2, sizeof(int), 1, fp);
fwrite(&height_image_S2, sizeof(int), 1, fp);
fwrite(&width_image_C3, sizeof(int), 1, fp);
fwrite(&height_image_C3, sizeof(int), 1, fp);
fwrite(&width_image_S4, sizeof(int), 1, fp);
fwrite(&height_image_S4, sizeof(int), 1, fp);
fwrite(&width_image_C5, sizeof(int), 1, fp);
fwrite(&height_image_C5, sizeof(int), 1, fp);
fwrite(&width_image_output, sizeof(int), 1, fp);
fwrite(&height_image_output, sizeof(int), 1, fp);

fwrite(&width_kernel_conv, sizeof(int), 1, fp);
fwrite(&height_kernel_conv, sizeof(int), 1, fp);
fwrite(&width_kernel_pooling, sizeof(int), 1, fp);
fwrite(&height_kernel_pooling, sizeof(int), 1, fp);

fwrite(&num_map_input, sizeof(int), 1, fp);
fwrite(&num_map_C1, sizeof(int), 1, fp);
fwrite(&num_map_S2, sizeof(int), 1, fp);
fwrite(&num_map_C3, sizeof(int), 1, fp);
fwrite(&num_map_S4, sizeof(int), 1, fp);
fwrite(&num_map_C5, sizeof(int), 1, fp);
fwrite(&num_map_output, sizeof(int), 1, fp);

fwrite(&len_weight_C1, sizeof(int), 1, fp);
fwrite(&len_bias_C1, sizeof(int), 1, fp);
fwrite(&len_weight_S2, sizeof(int), 1, fp);
fwrite(&len_bias_S2, sizeof(int), 1, fp);
fwrite(&len_weight_C3, sizeof(int), 1, fp);
fwrite(&len_bias_C3, sizeof(int), 1, fp);
fwrite(&len_weight_S4, sizeof(int), 1, fp);
fwrite(&len_bias_S4, sizeof(int), 1, fp);
fwrite(&len_weight_C5, sizeof(int), 1, fp);
fwrite(&len_bias_C5, sizeof(int), 1, fp);
fwrite(&len_weight_output, sizeof(int), 1, fp);
fwrite(&len_bias_output, sizeof(int), 1, fp);

fwrite(&num_neuron_input, sizeof(int), 1, fp);
fwrite(&num_neuron_C1, sizeof(int), 1, fp);
fwrite(&num_neuron_S2, sizeof(int), 1, fp);
fwrite(&num_neuron_C3, sizeof(int), 1, fp);
fwrite(&num_neuron_S4, sizeof(int), 1, fp);
fwrite(&num_neuron_C5, sizeof(int), 1, fp);
fwrite(&num_neuron_output, sizeof(int), 1, fp);

fwrite(weight_C1, sizeof(weight_C1), 1, fp);
fwrite(bias_C1, sizeof(bias_C1), 1, fp);
fwrite(weight_S2, sizeof(weight_S2), 1, fp);
fwrite(bias_S2, sizeof(bias_S2), 1, fp);
fwrite(weight_C3, sizeof(weight_C3), 1, fp);
fwrite(bias_C3, sizeof(bias_C3), 1, fp);
fwrite(weight_S4, sizeof(weight_S4), 1, fp);
fwrite(bias_S4, sizeof(bias_S4), 1, fp);
fwrite(weight_C5, sizeof(weight_C5), 1, fp);
fwrite(bias_C5, sizeof(bias_C5), 1, fp);
fwrite(weight_output, sizeof(weight_output), 1, fp);
fwrite(bias_output, sizeof(bias_output), 1, fp);

fflush(fp);
fclose(fp);

return true;
}

double CNN::test()
{
int count_accuracy = 0;

for (int num = 0; num < num_patterns_test_CNN; num++) {
data_single_image = data_input_test + num * num_neuron_input_CNN;
data_single_label = data_output_test + num * num_neuron_output_CNN;

Forward_C1();
Forward_S2();
Forward_C3();
Forward_S4();
Forward_C5();
Forward_output();

int pos_t = -1;
int pos_y = -2;
double max_value_t = -9999.0;
double max_value_y = -9999.0;

for (int i = 0; i < num_neuron_output_CNN; i++) {
if (neuron_output[i] > max_value_y) {
max_value_y = neuron_output[i];
pos_y = i;
}

if (data_single_label[i] > max_value_t) {
max_value_t = data_single_label[i];
pos_t = i;
}
}

if (pos_y == pos_t) {
++count_accuracy;
}

Sleep(1);
}

return (count_accuracy * 1.0 / num_patterns_test_CNN);
}

}

测试代码如下：
int test_CNN_train()
{
ANN::CNN cnn1;
cnn1.init();
cnn1.train();

return 0;
}

int test_CNN_predict()
{
ANN::CNN cnn2;
bool flag = cnn2.readModelFile("E:/GitCode/NN_Test/data/cnn.model");
if (!flag) {
std::cout << "read cnn model error" << std::endl;
return -1;
}

int width{ 32 }, height{ 32 };
std::vector target{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
std::string image_path{ "E:/GitCode/NN_Test/data/images/" };

for (auto i : target) {
std::string str = std::to_string(i);
str += ".png";
str = image_path + str;

cv::Mat src = cv::imread(str, 0);
if (src.data == nullptr) {
fprintf(stderr, "read image error: %s\n", str.c_str());
return -1;
}

cv::Mat tmp(src.rows, src.cols, CV_8UC1, cv::Scalar::all(255));
cv::subtract(tmp, src, tmp);

cv::resize(tmp, tmp, cv::Size(width, height));

auto ret = cnn2.predict(tmp.data, width, height);

fprintf(stdout, "the actual digit is: %d, correct digit is: %d\n", ret, i);
}

return 0;
}

通过执行test_CNN_train()函数可生成cnn model文件，执行结果如下：

卷积神经网络(CNN)的简单介绍及代码实现

通过执行test_CNN_predict()函数来测试CNN的准确率，通过画图工具，每个数字生成一张图像，共10幅，如下图：

测试结果如下：

卷积神经网络(CNN)的简单介绍及代码实现

阅读全文

上一页 1 2 3 4 5 6 7全文

本文导航

cnn(21235) cnn(21235)

什么是卷积神经网络？完整的卷积神经网络（CNNS）解析

卷积神经网络（CNN）是一种特殊类型的神经网络，在图像上表现特别出色。卷积神经网络由Yan LeCun在1998年提出，可以识别给定输入图像中存在的数字。

2022-08-10 11:49:06

18294

使用PyTorch深度解析卷积神经网络

2022-09-21 10:12:50

637

卷积神经网络(CNN)的工作原理神经网络的训练过程

前文《卷积神经网络简介：什么是机器学习？》中，我们比较了在微控制器中运行经典线性规划程序与运行CNN的区别，并展示了CNN的优势。我们还探讨了CIFAR网络，该网络可以对图像中的猫、房子或自行车等对象进行分类，还可以执行简单的语音识别。本文重点解释如何训练这些神经网络以解决实际问题。

2023-09-05 10:19:43

865

使用Python卷积神经网络(CNN)进行图像识别的基本步骤

Python 卷积神经网络（CNN）在图像识别领域具有广泛的应用。通过使用卷积神经网络，我们可以让计算机从图像中学习特征，从而实现对图像的分类、识别和分析等任务。以下是使用 Python 卷积神经网络进行图像识别的基本步骤。

2023-11-20 11:20:33

1469

卷积神经网络CNN介绍

【深度学习】卷积神经网络CNN

2020-06-14 18:55:37

卷积神经网络—深度卷积网络：实例探究及学习总结

《深度学习工程师-吴恩达》03卷积神经网络—深度卷积网络：实例探究学习总结

2020-05-22 17:15:57

卷积神经网络一维卷积的处理过程

。本文就以一维卷积神经网络为例谈谈怎么来进一步优化卷积神经网络使用的memory。文章（卷积神经网络中一维卷.

2021-12-23 06:16:40

卷积神经网络为什么适合图像处理？

卷积神经网络为什么适合图像处理？

2022-09-08 10:23:10

卷积神经网络入门资料

卷积神经网络入门详解

2019-02-12 13:58:26

卷积神经网络原理及发展过程

Top100论文导读：深入理解卷积神经网络CNN（Part Ⅰ）

2019-09-06 17:25:54

卷积神经网络如何使用

卷积神经网络(CNN)究竟是什么，鉴于神经网络在工程上经历了曲折的历史，您为什么还会在意它呢? 对于这些非常中肯的问题，我们似乎可以给出相对简明的答案。

2019-07-17 07:21:50

卷积神经网络模型发展及应用

十余年来快速发展的崭新领域，越来越受到研究者的关注。卷积神经网络（CNN）模型是深度学习模型中最重要的一种经典结构，其性能在近年来深度学习任务上逐步提高。由于可以自动学习样本数据的特征表示，卷积

2022-08-02 10:39:39

卷积神经网络的优点是什么

卷积神经网络的优点

2020-05-05 18:12:50

卷积神经网络的层级结构和常用框架

　　卷积神经网络的层级结构　　卷积神经网络的常用框架

2020-12-29 06:16:44

卷积神经网络的整体网络结构和发展过程

Top100论文导读：深入理解卷积神经网络CNN（Part Ⅱ）

2019-08-22 14:20:39

卷积神经网络简介：什么是机器学习？

抽象人工智能（AI）的世界正在迅速发展，人工智能越来越多地支持以前无法实现或非常难以实现的应用程序。本系列文章解释了卷积神经网络 （CNN）及其在 AI 系统中机器学习中的重要性。CNN 是从

2023-02-23 20:11:10

卷积神经网络（CNN）是如何定义的？

什么是卷积神经网络？ImageNet-2010网络结构是如何构成的？有哪些基本参数？

2021-06-17 11:48:22

简单神经网络的实现

最简单的神经网络

2019-09-11 11:57:36

TF之CNN：Tensorflow构建卷积神经网络CNN的嘻嘻哈哈事之详细攻略

TF之CNN：Tensorflow构建卷积神经网络CNN的嘻嘻哈哈事之详细攻略

2018-12-19 17:03:10

《 AI加速器架构设计与实现》+第一章卷积神经网络观后感

《 AI加速器架构设计与实现》+第一章卷积神经网络观感在本书的引言中也提到“一图胜千言”，读完第一章节后，对其进行了一些归纳（如图1），第一章对常见的神经网络结构进行了介绍，举例了一些结构

2023-09-11 20:34:01

【PYNQ-Z2申请】基于PYNQ的卷积神经网络加速

项目名称：基于PYNQ的卷积神经网络加速试用计划：申请理由：本人研究生在读，想要利用PYNQ深入探索卷积神经网络的硬件加速，在PYNQ上实现图像的快速处理项目计划：1、在PC端实现Lnet网络的训练

2018-12-19 11:37:22

什么是LSTM神经网络

简单理解LSTM神经网络

2021-01-28 07:16:57

什么是图卷积神经网络？

图卷积神经网络

2019-08-20 12:05:29

全连接神经网络和卷积神经网络有什么区别

全连接神经网络和卷积神经网络的区别

2019-06-06 14:21:42

关于卷积神经网络探秘的简单了解

卷积神经网络探秘

2019-06-04 11:59:35

利用Keras实现四种卷积神经网络(CNN)可视化

Keras实现卷积神经网络(CNN)可视化

2019-07-12 11:01:52

可分离卷积神经网络在 Cortex-M 处理器上实现关键词识别

，接下来是密集全连接层。● 深度可分离卷积神经网络 (DS-CNN)最近，深度可分离卷积神经网络被推荐为标准 3D 卷积运算的高效替代方案，并已用于实现计算机视觉的紧凑网络架构。DS-CNN 首先使用独立

2021-07-26 09:46:37

基于赛灵思FPGA的卷积神经网络实现设计

FPGA 上实现卷积神经网络 (CNN)。CNN 是一类深度神经网络，在处理大规模图像识别任务以及与机器学习类似的其他问题方面已大获成功。在当前案例中,针对在 FPGA 上实现 CNN 做一个可行性研究

2019-06-19 07:24:41

如何利用卷积神经网络去更好地控制巡线智能车呢

巡线智能车控制中的CNN网络有何应用？嵌入式单片机中的神经网络该怎样去使用？如何利用卷积神经网络去更好地控制巡线智能车呢？

2021-12-21 07:47:24

如何用卷积神经网络方法去解决机器监督学习下面的分类问题？

人工智能下面有哪些机器学习分支？如何用卷积神经网络（CNN）方法去解决机器学习监督学习下面的分类问题？

2021-06-16 08:09:03

如何移植一个CNN神经网络到FPGA中？

二次开发。移植一个神经网络到Lattice FPGA上可以分为三步：第一步：使用Tensorflow, Caffe, Keras训练自己的网络。（这里Lattice官网的参考设计提供了训练网络部分的参考代码

2020-11-26 07:46:03

解析深度学习：卷积神经网络原理与视觉实践

解析深度学习：卷积神经网络原理与视觉实践

2020-06-14 22:21:12

请问为什么要用卷积神经网络？

为什么要用卷积神经网络？

2020-06-13 13:11:39

非局部神经网络，打造未来神经网络基本组件

最高的精度。由此表明非局部模块可以作为一种比较通用的基本组件，在设计深度神经网络时使用。实验及结果在这一节我们简单介绍论文中描述的实验及结果。视频的基线模型是 ResNet-50 C2D。三维输出映射

2018-11-12 14:52:50

OpenVX 实现卷积神经网络扩展

去年12月，Imagination宣布率先实现OpenVX 1.1一致性。在本文中，我们将展示，自发布第一款Khronos OpenVX 1.1 API及第一次实现卷积神经网络(CNN)扩展以来，我们是如何开展工作。

2017-05-26 14:26:30

8521

卷积神经网络(CNN)基础详细说明及其注意事项

本文是对卷积神经网络的基础进行介绍，主要内容包括卷积神经网络概念、卷积神经网络结构、卷积神经网络求解、卷积神经网络LeNet-5结构分析、卷积神经网络注意事项。一、卷积神经网络概念上世纪60年代

2017-11-15 15:47:01

57765

【科普】卷积神经网络(CNN)基础介绍

对卷积神经网络的基础进行介绍，主要内容包括卷积神经网络概念、卷积神经网络结构、卷积神经网络求解、卷积神经网络LeNet-5结构分析、卷积神经网络注意事项。一、卷积神经网络概念上世纪60年代

2017-11-16 01:00:02

10694

卷积神经网络检测脸部关键点的教程之卷积神经网络训练与数据扩充

上一次我们用了单隐层的神经网络，效果还可以改善，这一次就使用CNN。卷积神经网络 上图演示了卷积操作 LeNet-5式的卷积神经网络，是计算机视觉领域近期取得的巨大突破的核心。卷积层和之前的全连接

2017-11-16 11:45:07

2012

卷积神经网络CNN图解

之前在网上搜索了好多好多关于CNN的文章，由于网络上的文章很多断章取义或者描述不清晰，看了很多youtobe上面的教学视频还是没有弄懂，最后经过痛苦漫长的煎熬之后对于神经网络和卷积有了粗浅的了解

2017-11-16 13:18:40

56168

卷积神经网络CNN架构分析-LeNet

对于神经网络和卷积有了粗浅的了解,关于CNN 卷积神经网络，需要总结深入的知识有很多：人工神经网络 ANN卷积神经网络CNN 卷积神经网络CNN-BP算法卷积神经网络CNN-caffe应用卷积神经网络CNN-LetNet分析 LetNet网络.

2017-11-16 13:28:01

2562

卷积神经网络CNN架构分析－ LeNet

2018-10-02 07:41:01

544

神经网络到卷积神经网络的原理

卷积神经网络 （Convolutional Neural Network， CNN）是一种源于人工神经网络（Neural Network， NN）的深度机器学习方法，近年来在图像识别领域取得了巨大

2021-03-25 09:45:21

MATLAB实现卷积神经网络CNN的源代码

MATLAB实现卷积神经网络CNN的源代码

2021-04-21 10:15:36

想了解卷积神经网络看这篇就够了

关于CNN，第1部分：卷积神经网络的介绍 CNN是什么？：它们如何工作，以及如何在Python中从头开始构建一个CNN。在过去的几年里，卷积神经网络（CNN）引起了人们的广泛关注，尤其是

2021-07-27 14:50:16

1705

什么是神经网络？什么是卷积神经网络？

在介绍卷积神经网络之前，我们先回顾一下神经网络的基本知识。就目前而言，神经网络是深度学习算法的核心，我们所熟知的很多深度学习算法的背后其实都是神经网络。

2023-02-23 09:14:44

2256

卷积神经网络简介：什么是机器学习？

随着人工智能(AI)技术的快速发展，AI可以越来越多地支持以前无法实现或者难以实现的应用。本文基于此解释了卷积神经网络(CNN)及其对人工智能和机器学习的意义。CNN是一种能够从复杂数据中提取特征

2023-03-11 23:10:04

523

干货速来！详析卷积神经网络(CNN)的特性和应用

前文《卷积神经网络简介：什么是机器学习？》中，我们比较了在微控制器中运行经典线性规划程序与运行CNN的区别，并展示了CNN的优势。我们还探讨了CIFAR网络，该网络可以对图像中的猫、房子或自行车

2023-03-27 22:50:02

556

【世说知识】干货速来！详析卷积神经网络(CNN)的特性和应用

本文重点解释如何训练卷积神经网络以解决实际问题。01神经网络的训练过程CIFAR网络由不同层的神经元组成。如图1所示，32×32像素的图像数据被呈现给网络并通过网络层传递。CNN处理过程的第一步就是

2023-04-09 14:23:37

375

卷积神经网络通俗理解

。本文将从通俗易懂的角度介绍卷积神经网络，让大家更好地理解这个重要的算法。卷积神经网络的概念在介绍卷积神经网络之前，先来看看卷积操作，因为卷积神经网络就是以卷积操作为基础的。卷积操作是一种数学上的操作，它可以将两个函数f和g产生第三个函数h。在机器

2023-08-17 16:30:25

2062

卷积神经网络包括哪几层

卷积神经网络包括哪几层卷积神经网络（Convolutional Neural Network, CNN）是一种前馈神经网络，通常被应用于图像识别和语音识别等领域。它的设计灵感来源于生物神经

2023-08-17 16:30:27

2147

卷积神经网络原理：卷积神经网络模型和卷积神经网络算法

卷积神经网络原理：卷积神经网络模型和卷积神经网络算法卷积神经网络（Convolutional Neural Network，CNN）是一种基于深度学习的人工神经网络，是深度学习技术的重要应用之

2023-08-17 16:30:30

806

卷积神经网络结构

Learning）的应用，通过运用多层卷积神经网络结构，可以自动地进行特征提取和学习，进而实现图像分类、物体识别、目标检测、语音识别和自然语言翻译等任务。卷积神经网络的结构包括：输入层、卷积层、激活函数、池化层和全连接层。在CNN中，输入层通常是代表图像的矩阵或向量，而卷积层是卷积神

2023-08-17 16:30:35

804

卷积神经网络python代码

的卷积操作，将不同层次的特征进行提取，从而通过反向传播算法不断优化网络权重，最终实现分类和预测等任务。在本文中，我们将介绍如何使用Python实现卷积神经网络，并详细说明每一个步骤及其原理。第一步：导入必要的库在开始编写代码前，我们需要先导入一些必要的Python库。具体如

2023-08-21 16:41:35

615

python卷积神经网络cnn的训练算法

python卷积神经网络cnn的训练算法卷积神经网络（Convolutional Neural Network，CNN）一直是深度学习领域重要的应用之一，被广泛应用于图像、视频、语音等领域

2023-08-21 16:41:37

859

卷积神经网络详解卷积神经网络包括哪几层及各层功能

多维数组而设计的神经网络。CNN不仅广泛应用于计算机视觉领域，还在自然语言处理、语音识别和游戏等领域有广泛应用。下文将详细地介绍CNN的各层及其功能。 1.卷积层(Convolutional

2023-08-21 16:41:40

4401

卷积神经网络的应用卷积神经网络通常用来处理什么

卷积神经网络的应用卷积神经网络通常用来处理什么卷积神经网络（Convolutional Neural Network，简称CNN）是一种在神经网络领域内广泛应用的神经网络模型。相较于传统

2023-08-21 16:41:45

3487

卷积神经网络概述卷积神经网络的特点 cnn卷积神经网络的优点

卷积神经网络概述卷积神经网络的特点 cnn卷积神经网络的优点卷积神经网络（Convolutional neural network，CNN）是一种基于深度学习技术的神经网络，由于其出色的性能

2023-08-21 16:41:48

1662

卷积神经网络模型有哪些？卷积神经网络包括哪几层内容？

卷积神经网络模型有哪些？卷积神经网络包括哪几层内容？卷积神经网络（Convolutional Neural Networks，CNN）是深度学习领域中最广泛应用的模型之一，主要应用于图像、语音

2023-08-21 16:41:52

1305

卷积神经网络模型训练步骤

模型训练是将模型结构和模型参数相结合，通过样本数据的学习训练模型，使得模型可以对新的样本数据进行准确的预测和分类。本文将详细介绍 CNN 模型训练的步骤。 CNN 模型结构卷积神经网络的输入

2023-08-21 16:42:00

885

卷积神经网络的工作原理卷积神经网络通俗解释

。CNN可以帮助人们实现许多有趣的任务，如图像分类、物体检测、语音识别、自然语言处理和视频分析等。本文将详细介绍卷积神经网络的工作原理并用通俗易懂的语言解释。 1.概述卷积神经网络是一个由神经元构成的深度神经网络，由输入层、隐藏层和输出层组成。在卷积神经网络中，

2023-08-21 16:49:24

2216

卷积神经网络如何识别图像

为多层卷积层、池化层和全连接层。CNN模型通过训练识别并学习高度复杂的图像模式，对于识别物体和进行图像分类等任务有着非常优越的表现。本文将会详细介绍卷积神经网络如何识别图像，主要包括以下几个方面： 1. 卷积神经网络的基本结构和原理 2. 卷积神经网络模型的训练过程 3.

2023-08-21 16:49:27

1284

卷积神经网络应用领域

卷积神经网络应用领域卷积神经网络(CNN)是一种广泛应用于图像、视频和自然语言处理领域的深度学习算法。它最初是用于图像识别领域，但目前已经扩展到了许多其他应用领域。本文将详细介绍卷积神经网络

2023-08-21 16:49:29

2029

卷积神经网络三大特点

卷积神经网络三大特点卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习模型，其具有三大特点：局部感知、参数共享和下采样。一、局部感知卷积神经网络

2023-08-21 16:49:32

3047

卷积神经网络的基本原理卷积神经网络发展卷积神经网络三大特点

卷积神经网络的基本原理卷积神经网络发展历程卷积神经网络三大特点卷积神经网络的基本原理卷积神经网络（Convolutional Neural Networks，CNN）是深度学习领域

2023-08-21 16:49:39

1144

卷积神经网络基本结构卷积神经网络主要包括什么

卷积神经网络基本结构卷积神经网络主要包括什么卷积神经网络（Convolutional Neural Network，简称CNN）是一种深度学习模型，广泛用于图像识别、自然语言处理、语音识别等领域

2023-08-21 16:57:19

3562

卷积神经网络层级结构卷积神经网络的卷积层讲解

卷积神经网络层级结构卷积神经网络的卷积层讲解卷积神经网络（Convolutional Neural Network，CNN）是一种基于深度学习的神经网络模型，在许多视觉相关的任务中表现出色，如图

2023-08-21 16:49:42

3760

卷积神经网络的介绍什么是卷积神经网络算法

卷积神经网络的介绍什么是卷积神经网络算法卷积神经网络涉及的关键技术卷积神经网络（Convolutional Neural Network，CNN）是一种用于图像分类、物体识别、语音识别等领域

2023-08-21 16:49:46

1229

卷积神经网络算法是机器算法吗

神经网络的原理先介绍一下卷积神经网络的原理。卷积神经网络中的核心结构是卷积层。卷积层中包含多组卷积核，每组卷积核会对输入数据进行卷积操作，生成一组输出特征图。每个输出特征图都对输入数据进行不同方向的滤波，提

2023-08-21 16:49:48

437

卷积神经网络算法比其他算法好吗

卷积神经网络算法比其他算法好吗卷积神经网络（Convolutional Neural Networks, CNN）是一种用于图像识别和处理等领域的深度学习算法。相对于传统的图像识别算法，如SIFT

2023-08-21 16:49:51

407

卷积神经网络算法原理

卷积神经网络算法原理卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习（Deep Learning）的模型，它能够自动地从图片、音频、文本等数据中提

2023-08-21 16:49:54

690

卷积神经网络是什么？卷积神经网络的工作原理和应用

　　卷积神经网络(Convolutional Neural Network，CNN)是一种深度学习神经网络，主要用于图像和视频的识别、分类和预测，是计算机视觉领域中应用最广泛的深度学习算法之一。该网络模型可以自动从原始数据中学习有用的特征，并将其映射到相应的类别。

2023-08-21 17:03:46

1064

卷积神经网络算法有哪些？

算法。它在图像识别、语音识别和自然语言处理等领域有着广泛的应用，成为近年来最为热门的人工智能算法之一。CNN基于卷积运算和池化操作，可以对图像进行有损压缩、提取特征，有效降低输入数据的维度，从而实现对大量数据的处理和分析。下面是对CNN算法的详细介绍： 1. 卷积神经网络的基本结构卷积神经网络的基本

2023-08-21 16:50:01

977

卷积神经网络算法三大类

卷积神经网络算法三大类卷积神经网络（Convolutional Neural Network，简称CNN）是一种常用的人工神经网络，它的主要应用领域是图像识别和计算机视觉方面。CNN通过卷积

2023-08-21 16:50:07

756

卷积神经网络算法代码python

卷积神经网络算法代码python 卷积神经网络（Convolutional Neural Network，CNN）是深度学习中最为重要的算法之一。它在计算机视觉、自然语言处理、语音识别等领域有着

2023-08-21 16:50:09

514

卷积神经网络算法代码matlab

卷积神经网络算法代码matlab 卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习网络模型，其特点是具有卷积层（Convolutional Layer

2023-08-21 16:50:11

745

卷积神经网络算法的核心思想

广泛应用的神经网络模型。本文将从以下几个方面详细介绍CNN的核心思想和算法原理。一、CNN简介 CNN是一种类似于人类视觉系统的神经网络模型，它利用卷积层、池化层、全连接层等多个层次对输入数据进行处理和特征提取，最终实现特定目标的分类和识别。CNN的典型应用包括图片识

2023-08-21 16:50:17

797

卷积神经网络算法流程卷积神经网络模型工作流程

卷积神经网络算法流程卷积神经网络模型工作流程卷积神经网络（Convolutional Neural Network，CNN）是一种广泛应用于目标跟踪、图像识别和语音识别等领域的深度学习模型

2023-08-21 16:50:19

1316

常见的卷积神经网络模型典型的卷积神经网络模型

常见的卷积神经网络模型典型的卷积神经网络模型卷积神经网络（Convolutional Neural Network, CNN）是深度学习中最流行的模型之一，其结构灵活，处理图像、音频、自然语言

2023-08-21 17:11:41

1646

cnn卷积神经网络模型卷积神经网络预测模型生成卷积神经网络模型

cnn卷积神经网络模型卷积神经网络预测模型生成卷积神经网络模型卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习神经网络，最初被广泛应用于计算机

2023-08-21 17:11:47

680

卷积神经网络模型搭建

卷积神经网络模型搭建卷积神经网络模型是一种深度学习算法。它已经成为了计算机视觉和自然语言处理等各种领域的主流算法，具有很大的应用前景。本篇文章将详细介绍卷积神经网络模型的搭建过程，为读者提供一份

2023-08-21 17:11:49

543

卷积神经网络一共有几层卷积神经网络模型三层

的神经网络，经过多层卷积、池化、非线性变换等复杂计算处理，可以从图像、音频、文本等数据中提取有用的特征。下文将详细介绍卷积神经网络的结构和原理。 CNN 的层级结构卷积神经网络一共有三层，分别是输入层、隐藏层和输出层。隐藏层包括卷积层、池化层和全连接层。其中，隐藏

2023-08-21 17:11:53

3332

卷积神经网络模型的优缺点

卷积神经网络模型的优缺点卷积神经网络（Convolutional Neural Network，CNN）是一种从图像、视频、声音和一系列多维信号中进行学习的深度学习模型。它在计算机视觉、语音识别

2023-08-21 17:15:19

1881

卷积神经网络主要包括哪些卷积神经网络组成部分

卷积神经网络主要包括哪些卷积神经网络组成部分卷积神经网络（CNN）是一类广泛应用于计算机视觉、自然语言处理等领域的人工神经网络。它具有良好的空间特征学习能力，能够处理具有二维或三维形状的输入数据

2023-08-21 17:15:22

938

cnn卷积神经网络原理 cnn卷积神经网络的特点是什么

cnn卷积神经网络原理 cnn卷积神经网络的特点是什么卷积神经网络（Convolutional Neural Network，CNN）是一种特殊的神经网络结构，主要应用于图像处理和计算机视觉领域

2023-08-21 17:15:25

1027

cnn卷积神经网络算法 cnn卷积神经网络模型

cnn卷积神经网络算法 cnn卷积神经网络模型卷积神经网络(CNN)是一种特殊的神经网络，具有很强的图像识别和数据分类能力。它通过学习权重和过滤器，自动提取图像和其他类型数据的特征。在过去的几年

2023-08-21 17:15:57

946

cnn卷积神经网络matlab代码

cnn卷积神经网络matlab代码卷积神经网络（Convolutional Neural Network, CNN）是深度学习中一种常用的神经网络结构，它是通过卷积层、池化层和全连接层等组合而成

2023-08-21 17:15:59

798

cnn卷积神经网络简介 cnn卷积神经网络代码

cnn卷积神经网络简介 cnn卷积神经网络代码卷积神经网络（Convolutional Neural Network，简称CNN）是目前深度学习领域中应用广泛的一种神经网络模型。CNN的出现

2023-08-21 17:16:13

1622

什么是卷积神经网络？为什么需要卷积神经网络？

卷积神经网络（Convolutional Neural Network，CNN）是一种用于处理具有类似网格结构的数据的神经网络。它广泛用于图像和视频识别、文本分类等领域。CNN可以自动从训练数据中学习出合适的特征，并以此对新输入的数据进行分类或回归等操作。

2023-08-22 18:20:37

1133

什么是卷积神经网络？如何MATLAB实现CNN？

卷积神经网络（CNN 或 ConvNet）是一种直接从数据中学习的深度学习网络架构。 CNN 特别适合在图像中寻找模式以识别对象、类和类别。它们也能很好地对音频、时间序列和信号数据进行分类。

2023-10-12 12:41:49

422

卷积神经网络通俗理解

卷积神经网络(Convolutional Neural Networks, CNN)是一类包含卷积计算且具有深度结构的前馈神经网络(Feedforward Neural Networks)，是深度

2023-11-26 16:26:01

506

卷积神经网络的优点

卷积神经网络的优点卷积神经网络（Convolutional Neural Network，CNN）是一种基于深度学习的神经网络模型，在图像识别、语音识别、自然语言处理等领域有着广泛的应用。相比

2023-12-07 15:37:25

2282

已全部加载完成

搜索历史

卷积神经网络(CNN)的简单介绍及代码实现 - 全文

本文导航

评论