【学习笔记】BP神经网络

最新推荐文章于 2024-07-10 21:16:19 发布
最新推荐文章于 2024-07-10 21:16:19 发布
阅读量231 收藏
点赞数
分类专栏： X | 学习笔记 B | BP网络 M | ML (DL & RL) 文章标签： BP 神经网络 前馈神经网络 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42102584/article/details/83480228
版权

嗯嗯... 看了 3Blue1Brown 的神经网络结构简介视频之后，觉得这个人工ZZ网络好好玩啊！遂入坑。

这是视频链接：https://www.bilibili.com/video/av15532370?from=search&seid=10137053428682538306

 

先挂一段代码... 这两天苦受各种DDL欺压，只能稍后再详细记录我的学习历程啦~

/* BP网络 by Kevin
 *
 * Supervised Learning 
 * for Classification (Multi-class Classification)
 *
 * 矩阵类：自敲，模板类（便于编译器检查行列匹配等问题） 
 * 隐含层层数：两层
 * 隐含层神经元个数：自定 
 * Tranint Data：4位二进制数 <-> 对应位置 
 * 前馈调节方式：梯度下降法 
 */


#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <vector>

typedef unsigned int uint;

template <uint R, uint C, typename Type = double>
class Matrix
{
	public:

		Type m[R][C];

	public:

		Matrix(void) { }
		Matrix(const Type val)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] = val;
		}
		Matrix(const Type inf, const Type sup)
		{
			const Type interval = (sup-inf) / RAND_MAX;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] = inf + interval * rand();
		}
		Matrix(const Matrix<R, C> &o)
		{
			memcpy(m, o.m, sizeof(m));
		}

		void random_init(const Type inf, const Type sup)
		{
			const Type interval = (sup-inf) / RAND_MAX;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] = inf + interval * rand();
		}

		void random_fix(const Type d)
		{
			const Type interval = 2*d / RAND_MAX;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					if (rand() < RAND_MAX/4)
						m[r][c] += interval * rand() - d;
		}

		inline Matrix<R, C> & operator =(const Matrix<R, C> &o)
		{
			if (this != &o)
				memcpy(m, o.m, sizeof(m));
			return *this;
		}

		inline auto operator [](int index) -> decltype(*m)
		{
			return m[index];
		}

		Matrix<C, R> transpose(void) const
		{
			Matrix<C, R> ret;
			for (int c=0; c<C; ++c)
				for (int r=0; r<R; ++r)
					ret.m[c][r] = m[r][c];
			return ret;
		}

		Matrix<C, R> operator ~(void) const
		{
			Matrix<C, R> ret;
			for (int c=0; c<C; ++c)
				for (int r=0; r<R; ++r)
					ret.m[c][r] = m[r][c];
			return ret;
		}

		Matrix<R, C> operator +(const Matrix<R, C> &o) const
		{
			Matrix<R, C> ret;

			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					ret.m[r][c] = m[r][c] + o.m[r][c];

			return ret;
		}

		const Matrix<R, C> & operator +=(const Matrix<R, C> &o)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] += o.m[r][c];

			return *this;
		}

		Matrix<R, C> operator -(const Matrix<R, C> &o) const
		{
			Matrix<R, C> ret;

			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					ret.m[r][c] = m[r][c] - o.m[r][c];

			return ret;
		}

		const Matrix<R, C> & operator -=(const Matrix<R, C> &o)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] -= o.m[r][c];

			return *this;
		}

		// {R, C} * {C, C1}
		template <uint C1>
		Matrix<R, C1> operator *(const Matrix<C, C1> &o) const
		{
			Matrix<R, C1> ret;

			for (int r=0; r<R; ++r)
				for (int c1=0; c1<C1; ++c1)
				{
					ret.m[r][c1] = *m[r] * (*m)[c1];
					for (int c=1; c<C; ++c)
						ret.m[r][c1] += m[r][c] * o.m[c][c1];
				}

			return ret;
		}

		// {R, C} ^ {R, C}
		Matrix<R, C> operator ^(const Matrix<R, C> &o) const
		{
			Matrix<R, C> ret;

			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					ret.m[r][c] = m[r][c] * o.m[r][c];

			return ret;
		}

		const Matrix<R, C> & operator ^=(const Matrix<R, C> &o)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] *= o.m[r][c];

			return *this;
		}

		friend Matrix<R, C> operator *(const Type val, const Matrix<R, C> &o)
		{
			Matrix<R, C> ret;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					ret.m[r][c] = o.m[r][c] * val;
			return ret;
		}

		Matrix<R, C> operator *(const Type val) const
		{
			Matrix<R, C> ret;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					ret.m[r][c] = m[r][c] * val;
			return ret;
		}

		const Matrix<R, C> & operator *=(const Type val)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					m[r][c] *= val;
			return *this;
		}

		// {R, C} * {R1, C1}
		template<uint R1, uint C1>
		Matrix <R * R1, C * C1> kronecker(const Matrix<R1, C1> &o) const
		{
			Matrix<R * R1, C * C1> ret;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					for (int r1=0; r1<R1; ++r1)
						for (int c1=0; c1<C1; ++c1)
							ret.m[r*R1 + r1][c*C1 + c1] = m[r][c] * o.m[r1][c1];
			return ret;
		}

		Type sq_sum(void) const
		{
			Type sum = 0.0;
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					sum += m[r][c] * m[r][c];
			return sum;
		}

		void println(void) const
		{
			for (int r=0; r<R; ++r, putchar(10))
				for (int c=0; c<C; ++c)
					printf("%f ", m[r][c]);
		}

		template <class Lambda>
		void for_each(Lambda lambda)
		{
			for (int r=0; r<R; ++r)
				for (int c=0; c<C; ++c)
					lambda(m[r][c]);
		}

		static constexpr double logsig(double x)
		{
			return 1 / (1 + exp(-x));
		}

		Matrix<R, C> actFunc(void) const
		{
			Matrix<R, C> ret;
			for (int c=0; c<C; ++c)
				(*ret.m)[c] = 1 / (1 + exp(-(*m)[c]));
			return ret;
		}

		Matrix<R, C> dActFunc(void) const
		{
			Matrix<R, C> ret;
			for (int c=0; c<C; ++c)
			{
				double temp = exp((*m)[c]);
				(*ret.m)[c] = temp / ((1+temp)*(1+temp));
			}
			return ret;
		}
};

void read_std_data(void);
void print_std_data(void);




constexpr int TEST_AMT(16);

constexpr int INPUT_AMT(4);
constexpr int OUTPUT_AMT(16);

constexpr float LEARNING_RATE(0.05);
constexpr double ERROR_LIMIT(0.0000001);





typedef Matrix<1, INPUT_AMT>  InputsType[TEST_AMT];
typedef Matrix<1, OUTPUT_AMT> OutputsType[TEST_AMT];


InputsType  stdInputs;
OutputsType stdOutputs;


template <uint L1_AMT, uint L2_AMT>
class BP
{
	private:

		int _i = INPUT_AMT;
		int _h1 = L1_AMT;
		int _h2 = L2_AMT;
		int _o = OUTPUT_AMT;

		InputsType		&inputs;		// 训练用输入（向量）
		OutputsType		&outputs;		// 训练用输入（向量）

		Matrix<  1	,		L1_AMT>			B1h1;	 // 第一层的偏置系数（向量）
		Matrix<INPUT_AMT,	L1_AMT>			Wih1;	 // 输入层和第一隐含层的突触（矩阵）
		Matrix<  1	,		L1_AMT>			H1h1;	 // 第一隐含层神经元（向量）
		Matrix<  1	,		L2_AMT>			B1h2;	 // 第二层的偏置系数（向量）
		Matrix<L1_AMT,		L2_AMT>			Wh1h2;	 // 第一和第二隐含层间的突触（矩阵）
		Matrix<  1	,		L2_AMT>			H1h2;	 // 第二隐含层神经元（向量）
		Matrix<  1	,		OUTPUT_AMT>		B1o;	 // 输出层的偏置系数（向量）
		Matrix<L2_AMT,		OUTPUT_AMT>		Wh2o;	 // 第二隐含层和输出层的突触（矩阵）

	public:

		BP(void) :
			inputs(stdInputs), outputs(stdOutputs) { }

		void init_inputs_and_outputs(const InputsType &inputs, const OutputsType &outputs)
		{
			this->inputs  = inputs;
			this->outputs = outputs;
		}

		void random_init(void)
		{
			H1h1.random_init(-1, 1);
			H1h2.random_init(-1, 1);
			Wih1.random_init(-1, 1);
			Wh1h2.random_init(-1, 1);
			Wh2o.random_init(-1, 1);
			B1h1.random_init(-1, 1);
			B1h2.random_init(-1, 1);
			B1o.random_init(-1, 1);
		}

		void random_init_better(uint count)
		{
			printf("random selecting (%d times)...\n", count);

			auto *bp = new BP<L1_AMT, L2_AMT>[count];
			for (int i=0; i<count; ++i)
			{
				bp[i].random_init();
			}

			uint minErrorIndex = 0;
			double minErrorValue = bp[0].get_error_sum();
			double maxErrorValue = minErrorValue;

			for (int i=1; i<count; ++i)
			{
				double nowErrorValue = bp[i].get_error_sum();
				if (minErrorValue > nowErrorValue)
				{
					minErrorValue = nowErrorValue;
					minErrorIndex = i;
				}
				if (maxErrorValue < nowErrorValue)
					maxErrorValue = nowErrorValue;
			}

			const BP<L1_AMT, L2_AMT> &best_bp = bp[minErrorIndex];
			this->B1h1  =  best_bp.B1h1;
			this->Wih1  =  best_bp.Wih1;
			this->H1h1  =  best_bp.H1h1;
			this->B1h2  =  best_bp.B1h2;
			this->Wh1h2 =  best_bp.Wh1h2;
			this->H1h2  =  best_bp.H1h2;
			this->B1o   =  best_bp.B1o;
			this->Wh2o  =  best_bp.Wh2o;

			printf("best: %f, worst: %f\n", minErrorValue, maxErrorValue);
			puts("random select OK!");
			delete []bp;
		}

		void evolution(uint count)
		{
			int minErrorIndex = -1;
			double minErrorValue = get_error_sum();

			BP<L1_AMT, L2_AMT> bp[count];

			for (int i=0; i<count; ++i)
			{
				bp[i].B1h1  =  this->B1h1;
				bp[i].B1h1.random_fix(0.01);
				bp[i].Wih1  =  this->Wih1;
				bp[i].Wih1.random_fix(0.01);
				bp[i].H1h1  =  this->H1h1;
				bp[i].H1h1.random_fix(0.01);
				bp[i].B1h2  =  this->B1h2;
				bp[i].B1h2.random_fix(0.01);
				bp[i].Wh1h2 =  this->Wh1h2;
				bp[i].Wh1h2.random_fix(0.01);
				bp[i].H1h2  =  this->H1h2;
				bp[i].H1h2.random_fix(0.01);
				bp[i].B1o   =  this->B1o;
				bp[i].B1o.random_fix(0.01);
				bp[i].Wh2o  =  this->Wh2o;
				bp[i].Wh2o.random_fix(0.01);

				double nowErrorValue = bp[i].get_error_sum();
				if (minErrorValue > nowErrorValue)
				{
					minErrorValue = nowErrorValue;
					minErrorIndex = i;
				}
			}

			if (minErrorIndex != -1)	// 变异出了更好的
			{
				this->B1h1  =  bp[minErrorIndex].B1h1;
				this->Wih1  =  bp[minErrorIndex].Wih1;
				this->H1h1  =  bp[minErrorIndex].H1h1;
				this->B1h2  =  bp[minErrorIndex].B1h2;
				this->Wh1h2 =  bp[minErrorIndex].Wh1h2;
				this->H1h2  =  bp[minErrorIndex].H1h2;
				this->B1o   =  bp[minErrorIndex].B1o;
				this->Wh2o  =  bp[minErrorIndex].Wh2o;
			}
		}

		void train(double rate = LEARNING_RATE, double error_limit = ERROR_LIMIT)
		{
			puts("\nstart training:\n");
			int times = 0;
			while (true)
			{
				evolution(32);
				++times;
				double error = 0;
				for (int t=0; t<TEST_AMT; t++)
				{
					const Matrix<1, INPUT_AMT> X1i = inputs[t];
					const Matrix<1, OUTPUT_AMT> Y1o = outputs[t];

					const Matrix<1, INPUT_AMT> O1i = X1i;

					Matrix<1, L1_AMT> X1h1 = O1i * Wih1;
					X1h1 = X1h1 + B1h1;
					const Matrix<1, L1_AMT> O1h1 = X1h1.actFunc();

					Matrix<1, L2_AMT> X1h2 = O1h1 * Wh1h2;
					X1h2 = X1h2 + B1h2;
					const Matrix<1, L2_AMT> O1h2 = X1h2.actFunc();

					Matrix<1, OUTPUT_AMT> X1o = O1h2 * Wh2o;
					X1o = X1o + B1o;
					const Matrix<1, OUTPUT_AMT> O1o = X1o.actFunc();

					const Matrix<1, OUTPUT_AMT> D1o = Y1o - O1o;
					Matrix<1, OUTPUT_AMT> E1o = D1o;
					E1o ^= X1o.dActFunc();

					const Matrix<OUTPUT_AMT, L2_AMT> Woh2 = ~Wh2o;
					const Matrix<1, L2_AMT> D1h2 = E1o * Woh2;
					Matrix<1, L2_AMT> E1h2 = D1h2;
					E1h2 ^= X1h2.dActFunc();

					const Matrix<L2_AMT, L1_AMT> Wh2h1 = ~Wh1h2;
					const Matrix<1, L1_AMT> D1h1 = E1h2 * Wh2h1;
					Matrix<1, L1_AMT> E1h1 = D1h1;
					E1h1 ^= X1h1.dActFunc();

					error += D1o.sq_sum() / 2;

					Wih1 += rate * ((~O1i).kronecker(E1h1));
					B1h1 += rate * E1h1;

					Wh1h2 += rate * ((~O1h1).kronecker(E1h2));
					B1h2 += rate * E1h2;

					Wh2o += rate * ((~O1h2).kronecker(E1o));
					B1o  += rate * E1o;
				}
				if ((times & 8191) == 0 || times == 1)
				{
					printf("迭代次数：%d，均方误差：%f，各自输出: \n", times, error);
					training_test();
				}
				if (error < error_limit)
				{
					printf("\n====================== 训练完成！======================\n迭代次数：%d，均方误差：%g\n绝对误差: \n", times, error);
					final_test();
					break;
				}
			}
		}

		double get_error_sum(void)
		{
			double error_sum = 0.0;
			for (int t=0; t<TEST_AMT; ++t)
			{
				const Matrix<1, INPUT_AMT> X1i = inputs[t];
				const Matrix<1, OUTPUT_AMT> Y1o = outputs[t];

				const Matrix<1, INPUT_AMT> O1i = X1i;

				Matrix<1, L1_AMT> X1h1 = O1i * Wih1;
				X1h1 = X1h1 + B1h1;
				const Matrix<1, L1_AMT> O1h1 = X1h1.actFunc();

				Matrix<1, L2_AMT> X1h2 = O1h1 * Wh1h2;
				X1h2 = X1h2 + B1h2;
				const Matrix<1, L2_AMT> O1h2 = X1h2.actFunc();

				Matrix<1, OUTPUT_AMT> X1o = O1h2 * Wh2o;
				X1o = X1o + B1o;
				const Matrix<1, OUTPUT_AMT> O1o = X1o.actFunc();

				const Matrix<1, OUTPUT_AMT> D1o = Y1o - O1o;

				error_sum += D1o.sq_sum();
			}
			return error_sum;
		}

		void training_test(void)
		{
			for (int t=0; t<TEST_AMT; ++t)
			{
				const Matrix<1, INPUT_AMT> X1i = inputs[t];
				const Matrix<1, OUTPUT_AMT> Y1o = outputs[t];

				const Matrix<1, INPUT_AMT> O1i = X1i;

				Matrix<1, L1_AMT> X1h1 = O1i * Wih1;
				X1h1 = X1h1 + B1h1;
				const Matrix<1, L1_AMT> O1h1 = X1h1.actFunc();

				Matrix<1, L2_AMT> X1h2 = O1h1 * Wh1h2;
				X1h2 = X1h2 + B1h2;
				const Matrix<1, L2_AMT> O1h2 = X1h2.actFunc();

				Matrix<1, OUTPUT_AMT> X1o = O1h2 * Wh2o;
				X1o = X1o + B1o;
				const Matrix<1, OUTPUT_AMT> O1o = X1o.actFunc();

				printf("[ ");
				for (int t=0; t<OUTPUT_AMT; ++t)
					if(fabs(O1o.m[0][t]) > 0.0001)printf("%.4f ", O1o.m[0][t]);
					else printf(" ----  ");
				printf("]\n");
			}
			printf("\n");
		}

		void final_test(void)
		{
			for (int t=0; t<TEST_AMT; ++t)
			{
				const Matrix<1, INPUT_AMT> X1i = inputs[t];
				const Matrix<1, OUTPUT_AMT> Y1o = outputs[t];

				const Matrix<1, INPUT_AMT> O1i = X1i;

				Matrix<1, L1_AMT> X1h1 = O1i * Wih1;
				X1h1 = X1h1 + B1h1;
				const Matrix<1, L1_AMT> O1h1 = X1h1.actFunc();

				Matrix<1, L2_AMT> X1h2 = O1h1 * Wh1h2;
				X1h2 = X1h2 + B1h2;
				const Matrix<1, L2_AMT> O1h2 = X1h2.actFunc();

				Matrix<1, OUTPUT_AMT> X1o = O1h2 * Wh2o;
				X1o = X1o + B1o;
				const Matrix<1, OUTPUT_AMT> O1o = X1o.actFunc();

				printf("[ ");
				for (int t=0; t<OUTPUT_AMT; ++t)
					printf("%.4f ", O1o.m[0][t]);
				printf("]\n");
			}
			printf("\n");
		}
};

void read_std_data(void)
{
	Matrix<1, INPUT_AMT> tInput;
	Matrix<1, OUTPUT_AMT> tOutput;

	std::ifstream fin("in.txt");
	if (fin.is_open())
	{
		for (int i=0; i<TEST_AMT; ++i)
		{
			for (int t=0; t<INPUT_AMT; ++t)
				fin >> tInput[0][t];
			for (int t=0; t<OUTPUT_AMT; ++t)
				fin >> tOutput[0][t];
			stdInputs[i] = tInput;
			stdOutputs[i] = tOutput;
		}
		fin.close();
	}
}

void print_std_data(void)
{
	for (int i=0; i<TEST_AMT; ++i)
	{
		for (int t=0; t<INPUT_AMT; ++t)
			std::cout << stdInputs[i][0][t] << ' ';
		for (int t=0; t<OUTPUT_AMT; ++t)
			std::cout << stdOutputs[i][0][t] << ' ';
		std::cout << '\n';
	}
}

int main()
{
	srand(time(nullptr));

	read_std_data();

	BP<8, 8> bp;
	bp.random_init_better(50000);

	bp.train();
}

 

Keyu Tian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BP神经网络.zip
11-16
另一篇文档“机器学习入门学习笔记：（一）BP神经网络原理推导及程序实现 - 做人要厚道_xu - 博客园.pdf”可能更侧重于理论部分，深入探讨了BP算法的数学原理，如链式法则在误差反向传播中的应用，以及如何通过梯度...
基于BP神经网络模型的笔记本电脑销售预测研究
05-18
5. BP神经网络模型可以与其他机器学习算法结合，提高模型的泛化能力和预测准确度。 相关术语： * BP神经网络模型 * 笔记本电脑销售预测 * 神经网络 * 机器学习 * 非线性映射 *泛化能力 * 库存管理 * 销售计划 * ...
python中init方法和随机数方法
努力给自己想要的
01-07 1830
1、__init__方法的使用 2、random方法的使用   在python中，有一些方法是特殊的，是以两个下划线开始，两个下划线结束，定义类，最常用的方法就是__init__()方法，这是类的初始化方法，类似于C#或Java的构造函数。在创建对象的时候自动执行。 class Person(object): ''' 这里定义的属性 为 静态的 ''' empCou...
BP神经网络入门 学习笔记
Charles
07-06 1054
BP是 Back Propagation 的简写 ，意思是反向传播。BP网络能学习和存贮大量的输入-输出模式映射关系，而无需事前揭示描述这种映射关系的数学方程。
BP神经网络学习笔记
crhxiyhx的博客
04-18 1203
一、简单理解 bp是back propagation的简写，意思为反向传播。而网络，我找到了下面这个三层网络的图， 我感觉这个图还是可以看的，将N看作输入层，R作为输出层，N1—N5作为隐藏层，M1—M5看作输入层到隐藏层的权重，A1—A5为隐藏层到输出层的权重。而这个图的计算也比较简单，R=N*M1*A1+N*M2*A2+N*M3*A3+N*M4*A4+N*M5*A5.。这个图并非神经网络，他只是一个普通的网络，因为它是单向传播的，神经网络是可以反向传播的网络。 二、BP神经网络的 ...
CV学习笔记-BP神经网络代码Python实例
Moresweet 猫甜
07-28 7075
实现简单的BP神经网络的实例编写，面向对象的思路编写，可以手动调参方便更改，更改应哟用不必大量重构，欢迎初学者学习，本篇代码涵盖了神经网络的输入层、隐藏层、输出层，实现了简单的实例使用。......
机器学习笔记-BP神经网络
小刘同学要努力的博客
11-27 395
机器学习 BP神经网络
（学习笔记）BP神经网络
weixin_46720804的博客
04-14 592
BP神经网络
BP神经网络算法原理-bp神经网络模型-bp神经网络代码matlab-学习笔记
botf201802的博客
04-20 1352
matlab提供了一个工具箱来实现BP神经网络，bp神经网络模型matlab工具箱还提供了非常多的训练算法，不过默认一般使用trainlm算法。BP神经网络的原理就像下面的图一样，模仿人的大脑的原理，把看到的东西作为输入，然后经过大脑，最后作为输出。在学习一段时间后，开始有些知识有些遗忘，所以整理一下，作为自己的学习笔记，以及帮助其他人学习。这是一个只有一个隐层的BP神经网络(加上输入层、输出层，称为三层BP神经网络)，在代码中我们用到newff函数，train函数，sim函数，具体的意义可以参考。
神经网络学习笔记
m0_61809644的博客
04-09 170
解决浅层全连接网络拟合效果不好、权值过多的问题：信息分层处理，每一层在上层提取特征的基础上获取进行再处理，得到更高级别的特征。填充（Padding），也就是在矩阵的边界上填充一些值，以增加矩阵的大小，通常用0或者复制边界像素来进行填充。注意，图像卷积时，根据定义，需要首先把卷积核上下左右转置。此处卷积核（黄色）是对称的，所以忽视。链接权过多，算的慢，难收敛，同时可能进入局部极小值，也容易产生过拟合问题，例如。减少权值连接，每一个节点只连到上一层的少数神经元，即局部连接。为解决算的慢的问题，
BP神经网络入门学习笔记
runtuandme的博客
09-05 632
因为要用到神经网络算法，之前接触过一些机器学习的皮毛还是半知半解，先着手练习一些比较好理解的小项目吧，开始： 文章目录回归模型（keras）一元二次模型 回归模型（keras） 一元二次模型 其实是做了个一元线性模型的，因为比较简单就放了（这个也很简单了。。） 先放模型： y=x2+1y=x^2+1y=x2+1 简单吧 样本训练数据随机模拟就好了。引入tf库中的keras模块： import nu...
神经网络学习笔记1——BP神经网络原理到编程实现（matlab，python）
热门推荐
weixin_56619527的博客
01-13 5万+
神经网络学习笔记1——BP神经网络原理到编程实现（matlab，python）
神经网络学习 之 BP神经网络.pdf
03-20
BP神经网络学习笔记 BP神经网络是神经网络学习中的一种重要算法，以下是BP神经网络的详细知识点： 第一章 概述 BP神经网络是反馈神经网络的一种， BP全称为Back Propagation，意为反向传播算法。BP神经网络是一种...
小白的机器学习笔记系列 之七 - 简单的BP神经网络实例
04-04
系列文章 小白的机器学习笔记系列 之七 - 简单的BP神经网络实例 的源码。Jupyter Notebook里可以直接运行。相关文章，参照以下链接。 https://blog.csdn.net/deecheanW/article/details/105308306
学习笔记-BP网络
12-01
BP网络是一种多层前馈神经网络，应用比较广泛，这是我看了之后的一些学习笔记
cs231n作业2 双层神经网络
m0_52775136的博客
07-07 721
还可以理解为dropout是一个正则化的操作，他在每次训练的时候，强行让一些feature为0，这样提高了网络的稀疏表达能力。Batch Normalization解决的一个重要问题就是梯度饱和。Forward: 计算score，再根据score计算loss。Backward：分别对W2、b2、W1、b1求梯度。使用slover来对神经网络进优化求解。卷积层的前向传播与反向传播。
神经网络设计过程
Water_Sunzhipeng的博客
07-08 401
转化为Iris Y(1, 3) = X (1, 4) * W(4, 3) + b(3,) 三个偏置项。梯度下降法：沿损失函数梯度下降的方向，寻找损失函数的最小值，得到最优的参数的方法。2.神经网络方法，采集大量的Iris特征，分类对应标签，构成数据集。学习率：当学习率设置的过小时，收敛过程变得缓慢，过大，会在错过最小值。损失函数可以判断当前W和b的优劣，当损失函数值最小时，W和b最优。损失函数的表达方法之一就是：均方误差：MSE(y, y_) =运用损失函数定义预测值(y)与标准答案(y_)之间的差距。
人工智能、机器学习、神经网络、深度学习和卷积神经网络的概念和关系
xrgs_shz的博客
07-07 746
深度学习通过组合低层特征形成更加抽象的高层表示属性类别或特征，以发现数据的有效表示，而这种使用相对较短、稠密的向量表示叫做分布式特征表示（也可以称为嵌入式表示）。研究深度学习的动机在于建立模拟人脑进行分析学习的神经网络，它模仿人脑的机制来解释数据，例如图像，声音和文本等。又称为机器智能，是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能是智能学科重要的组成部分，它企图了解智能的实质，并生产出一种新的能以与。核心，是使计算机具有智能的根本途径。
【AI前沿】深度学习基础：训练神经网络
最新发布
屿小夏.的知识博客
07-10 673
深度学习是当今人工智能领域的核心技术，尤其在图像处理、语音识别、自然语言处理等领域表现出色。要理解深度学习，首先需要掌握神经网络的训练过程，包括前向传播、反向传播、损失函数、优化算法以及梯度下降法及其变种。
神经网络梯度推导1
08-03
神经网络梯度推导1

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值