结构体

结构体

结构体的定义和使用

创建结构体变量有三种方式，在代码中展示

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include<iostream>
#include<string>
using namespace std;
//结构体
struct student
{
	//成员列表
	string s_Name;
	int s_Age;
	int s_Grade;
}s3;
void test01()
{
	//结构体创建变量一
	struct student s1;
	s1.s_Name="桂";
	s1.s_Age=20;
	s1.s_Grade=91;
	cout<<"s1.s_Name= "<<s1.s_Name<<endl;
	cout<<"s1.s_Age= "<<s1.s_Age<<endl;
	cout<<"s1.s_Grade= "<<s1.s_Grade<<endl; 
}
void test02()
{
	struct student s2{"王",19,96};
	cout<<"s2.s_Name= "<<s2.s_Name<<endl;
	cout<<"s2.s_Age= "<<s2.s_Age<<endl;
	cout<<"s2.s_Grade= "<<s2.s_Grade<<endl; 
}
void test03()
{
	//在创建结构体时创建变量
	s3.s_Name="文";
	s3.s_Age=18;
	s3.s_Grade=78;
	cout<<"s3.s_Name= "<<s3.s_Name<<endl;
	cout<<"s3.s_Age= "<<s3.s_Age<<endl;
	cout<<"s3.s_Grade= "<<s3.s_Grade<<endl; 
	 
}
int main()
{
	test03();
	system("pause");
	return 0;
}

结构体数组

作用：将自定义的结构体放入到数组中方便维护

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include<iostream>
#include<string>
using namespace std;
//结构体数组
 
//1.定义结构体
//2.创建结构体数组
//3.给结构体中的元素赋值
//4.遍历结构体数组 
struct student
{
	string m_Name;
	int m_Age;
	int m_Grade;
};

void test()
{
   int i;
	//创建结构体数组 
   struct student arry[3]=
   {
   	  {"桂",20,100}, 
	  {"王",19,90},
	  {"李",17,45}
   };
   //修改结构体数组中的值
   arry[1].m_Name="赵";
   //输出数组中的值
   for(i=0;i<3;i++)
   {
   	cout<<"第"<<i+1<<"个人的信息:"<<endl; 
   	cout<<"m_Name= "<<arry[i].m_Name<<endl;
   	cout<<"m_Age= "<<arry[i].m_Age<<endl;
   	cout<<"m_Grade= "<<arry[i].m_Grade<<endl;
   } 
}
int main()
{
	test();
	system("pause");
	return 0;
}

结构体指针

利用->可以通过结构体指针访问属性

三步：

1.创建学生结构体变量

2.通过指针指向结构体变量

3.通过指针访问结构体变量中的数据，(通过结构体指针 访问结构体中的属性，需要利用”->” )

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include<iostream>
using namespace std;
//结构体指针
struct student
{
	string s_Name;
	int s_Age;
	int s_Score;
};
void test()
{
	//1.创建学生结构体变量 
	struct student s={"桂",20,99};
	//2.通过指针指向结构体变量 
	struct student *p=&s;
	//3.通过指针访问结构体变量中的数据
	//通过结构体指针 访问结构体中的属性，需要利用"->" 
	cout<<"s_Name= "<<p->s_Name<<endl;
	cout<<"s_Age= "<<p->s_Age<<endl;
	cout<<"s_Score= "<<p->s_Score<<endl;	
}
int main()
{
	test();
	system("pause");
	return 0;
}

结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<iostream>
using namespace std;
#include<string>

struct student
{
	string s_Name;
	int s_Age;
	int s_Grade;
};

struct teacher
{
	int id;
	string name;
	int age;
	struct student s; //嵌套学生结构体 
};
void test()
{
	teacher t;
	t.name="wang";
	t.id=1001;
	t.age=50;
	t.s.s_Name="桂";
	t.s.s_Age=20;
	t.s.s_Grade=98;
	cout<<"t.name= "<<t.name<<endl;
	cout<<"t.id= "<<t.id<<endl;
	cout<<"t.age= "<<t.age<<endl;
	cout<<"t.s.s_Name= "<<t.s.s_Name<<endl;
	cout<<"t.s.s_Age= "<<t.s.s_Age<<endl;
	cout<<"t.s.s_Grade= "<<t.s.s_Grade<<endl;	 
}
int main()
{
	test();
	system("pause");
	return 0;
}

结构体做函数参数

作用：将结构体作为参数向函数中传递

传递的方式有两种：

值传递

地址传递

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include<iostream>
#include<string>
using namespace std;
//学生结构体
struct student
{
	string name;
	int age;
	int score;
};

void test01(student ss) //值传递 
{
	cout<<"值传递到输出结果"<<endl;
	cout<<"s.name= "<<ss.name<<endl;
	cout<<"s.age= "<<ss.age<<endl;
	cout<<"s.score= "<<ss.score<<endl;
}

void test02(student *p) //地址传递 
{
	cout<<"地址传递到输出结果"<<endl;
	cout<<"p->name= "<<p->name<<endl;
	cout<<"p->age= "<<p->age<<endl;
	cout<<"p->score= "<<p->score<<endl;	
}
int main()
{
	struct student s;
	s.name="桂";
	s.age=20;
	s.score=89;
	//test01(s);  //值传递测试 
	test02(&s);   //地址传递测试 
	system("pause");
	return 0;
}

总结：如果不想修改主函数里面的值，则用值传递，否则用地址传递

结构体中的const使用场景

作用：用const来防止误操作

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include<iostream>
#include<string>
using namespace std;
struct student
{
	string name;
	int age;
	int score;
};

void test(const struct student *p)
{
	//为了防止在子函数中的错误操作导致主函数中的值发生改变，可以在形参列表引入const 
	//p->age=25; //语句错误，无法执行 
	cout<<"p->name= "<<p->name<<endl;
	cout<<"p->age= "<<p->age<<endl;
	cout<<"p->score= "<<p->score<<endl;
} 
int main()
{
	struct student s={"桂",20,99};
	//利用地址传递可以用来减少占用的内存空间 
	test(&s);
	system("pause");
	return 0;
}

案例

案例1

案例描述

​ 学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下，设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和存放5名学生的数组作为成员，学生的成员有姓名，考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带学生的数据

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
//学生结构体
struct student
{
   string s_name;
   int score;
   
};
//老师结构体
struct teacher
{
	string t_name;
	struct student Sarry[5];
}; 
void test(struct teacher Tarry[],int len)
{
	int i,j;
	string nameSeed="ABCDE";
	for(i=0;i<len;i++)
	{
		Tarry[i].t_name="Teacher_";
		Tarry[i].t_name+=nameSeed[i];
		for(j=0;j<5;j++)
		{
			Tarry[i].Sarry[j].s_name="Student_";
			Tarry[i].Sarry[j].s_name+=nameSeed[j];
			int num=rand ()% 61+40; //40到99之间的分数 
			Tarry[i].Sarry[j].score=num;
		}
	}
} 

//Print
void Print(struct teacher Tarry[],int len)
{
	int i,j;
	for(i=0;i<len;i++)
	{
		cout<<"第"<<i+1<<"个老师信息及该位学生的信息"<<endl;
		cout<<"老师姓名: "<<Tarry[i].t_name<<endl;
		for(j=0;j<5;j++)
		{
			cout<<"第"<<j+1<<"个学生"<<endl;
			cout<<"\tname= "<<Tarry[i].Sarry[j].s_name<<endl;
			cout<<"\tscore= "<<Tarry[i].Sarry[j].score<<endl;
		} 
	}
}
int main()
{
	struct teacher Tarr[3]; //创建老师数组 
	int len=sizeof(Tarr)/sizeof(Tarr[0]);
	//初始化函数 
	test(Tarr,len);
	//打印输出函数
	Print(Tarr,len); 
	system("pause");
	return 0;
}

案例2

​ 设计一个英雄结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄，通过冒泡排序算法，将数组中的英雄按照年龄进行排序，最终打印排序后的结果

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include<iostream>
#include<string> 
using namespace std;
struct hero
{
	string name;
	int age;
	string sex;    //性别 
};
void bubble(struct hero Arry[],int len)
{
	int i,j;
	for(i=0;i<len-1;i++)
	{
		for(j=0;j<len-i-1;j++)
		{
			if(Arry[j].age>Arry[j+1].age)
			{
				struct hero temp=Arry[j];
				Arry[j]=Arry[j+1];
				Arry[j+1]=temp;
			}
		}
	}
}
void Print(struct hero Arry[],int len)
{
	int i;
	for(i=0;i<len;i++)
	{
		cout<<"第"<<i+1<<"个人英雄资料"<<endl; 
		cout<<"name= "<<Arry[i].name<<endl;
		cout<<"age= "<<Arry[i].age<<endl;
		cout<<"sex= "<<Arry[i].sex<<endl;	
	}
}
int main()
{
	struct hero arry[5]={{"刘备",23,"男"},{"关羽",22,"男"},{"张飞",20,"男"},{"赵云",21,"男"},{"貂蝉",19,"女"}};
	bubble(arry,5);
	Print(arry,5);
	system("pause");
	return 0;
}

展开全文 >>

指针

指针

空指针

空指针不是我们申请的空间，不能进行访问

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
    int *p=NULL;  //空指针
    cout<<"*p= "<<*p<<endl;  //无法访问
    system("pause");
    return 0;
}

野指针

指针变量指向非法的内存空间

1
2
3
4
5
6
7
8
9
int main()
{
    //指针变量p指向内存地址编号为0x1100的空间
    int * p=(int *)0x1100;
    //访问野指针会报错
    cout<<* p<<endl;
    system("pause");
    return 0;
}

const—指针

1.const修饰指针，简称常量指针

特点：指针的指向可以修改，指针指向的值不能修改

2.const修饰常量，简称指针常量

特点：指针的指向不可以修改，指针指向的值可以修改

3.const既修饰指针又修饰常量

特点：指针的指向和指针指向的值都不能修改

代码1.

1
2
3
4
5
6
7
8
9
10
11
12
13
//1.常量指针 
void test()
{
	int a=100,b=200;
	const int * p=&a;
	cout<<"*p= "<<*p<<endl;  //输出改变方向前的值 
	p=&b;    //改变指针指向的方向 
	cout<<"*p= "<<*p<<endl;  //输出改变方向后的值 
	//*p=50;//错误 
}
//结果
*p= 100
*p= 200

代码2.

1
2
3
4
5
6
7
8
9
10
11
12
13
//2.指针常量 
void test02()
{
	int a=100,b=200;
	int * const p=&a;
	cout<<"改变前的指针的值 *p= "<<*p<<endl;
	*p=50;    //修改指针指向的值
	cout<<"改变后的指针的值 *p= "<<*p<<endl;
	//p=&b; //指针的指向不能修改 
}
//结果
改变前的指针的值 *p= 100
改变后的指针的值 *p= 50

代码3.

1
2
3
4
5
6
7
8
9
10
//3.既修饰指针又修饰常量
void test03() 
{
	int a=100,b=200;
	const int * const p=&a;
	cout<<"*p= "<<*p<<endl;
	//*p=200;  //指针的值不能修改
	//p=&b;    //指针的指向不能修改
	//cout<<*p<<endl; 
}

指针和数组

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<iostream>
using namespace std;
void test01()
{
	int arr[]={3,2,1,5,4,8,6}; 
	int *p=arr;  //数组的名arr就是数组的首地址
	cout<<"利用指针访问数组中的第一个元素"<<*p<<endl;
	cout<<"用指针遍历数组"<<endl;
	for(int i=0;i<7;i++)
	{
		cout<<*(p+i)<<" "<<endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

指针和函数

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<iostream>
using namespace std;
//值传递
void test01(int x,int y)
{
	int temp=x;
	x=y;
	y=temp;
} 
//地址传递
void test02(int *q,int *p)
{
	int temp=*q;
	*q=*p;
	*p=temp;
} 

int main()
{
	int a=10,b=20;
	
	test01(a,b);
	cout<<"值传递"<<endl; 
	cout<<"a= "<<a<<" "<<"b= "<<b<<endl;
	test02(&a,&b);
	cout<<"地址传递"<<endl;
	cout<<"a= "<<a<<" "<<"b= "<<b<<endl;
	system("pause");
	return 0;
}

案例

指针配合函数和数组使用案例

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<iostream>
using namespace std;
int a[100];
void test01(int a[],int l)
{
	int i,j;
	for(i=0;i<l-1;i++)
	{
		for(j=i;j<l;j++)
		{
			if(a[j]<a[i])
			{
				int temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
		}
	}
}
int main()
{
	int n,i;
	cout<<"请输入排序的数目"<<endl;
	cin>>n; 
	for(i=0;i<n;i++)
		cin>>a[i];
	test01(a,n);
	for(i=0;i<n;i++)
		cout<<a[i]<<" ";
	system("pause");
	return 0;
	
}

展开全文 >>

冰墩墩代码来啦

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
import turtle as t

t.speed(20)     #画笔速度
t.title("冰墩墩")

#画出左耳
t.penup()   #起笔
t.goto(-130,150) #将画笔移动到指定位置
t.setheading(160) #设置当前朝向的角度
t.begin_fill()    #开始填充图形
t.pendown()
t.circle(-30, 230)
t.setheading(180) #设置当前朝向的角度
t.circle(37, 90)  #画圆，半径为正(负)，表示圆心在画笔的左边(右边)画圆
t.end_fill()      #填充结束
#画右耳   多多注意与画左耳的区别 很多参数都是相反的
t.penup()
t.goto(130,150)
t.setheading(20)
t.begin_fill()
t.pendown()
t.circle(30,230)
t.setheading(0)
t.circle(-37,90)
t.end_fill()


#画头
#1.画上半部分头
t.pensize(6)  #设置画笔宽度为6
t.penup()
t.goto(0,230) #移动到合适位置
t.setheading(5)
t.pendown()
t.circle(-134,60)

t.pensize(6)  #设置画笔宽度为6
t.penup()
t.goto(0,230) #移动到合适位置
t.setheading(-185)
t.pendown()
t.circle(134,60)
#2.画下半部分头
#2.1 右半部分
t.penup()
t.goto(130, 150)
t.setheading(-65)
t.pendown()
t.circle(-200, 90)
#2.2 左半部分
t.penup()
t.goto(-130, 150)
t.setheading(-115)
t.pendown()
t.circle(200, 90)
#2.3 下半部分
t.penup()
t.setheading(-31)
t.pendown()
t.circle(60, 60)

#眼睛

#左眼眼圈
t.speed(1000)
t.penup()
t.goto(-110, 90)
t.setheading(-45)
t.begin_fill()
t.pendown()
a = 0.2
for i in range(120):
    if 0 <= i < 30 or 60 <= i < 90:
        a = a + 0.1
        t.speed(100)
        t.lt(3)  # 向左转3度
        t.fd(a)  # 向前走a的步长
    else:
        a = a - 0.1
        t.speed(100)
        t.lt(3)
        t.fd(a)
t.end_fill()
# 左眼眼白
t.fillcolor("white")
t.penup()
t.goto(-70, 110)
t.setheading(0)
t.begin_fill()
t.pendown()
t.circle(14, 360)
t.end_fill()
# 左眼眼珠
t.penup()
t.goto(-70, 117)
t.setheading(0)
t.begin_fill()
t.pendown()
t.circle(6, 360)
t.end_fill()

#右眼眼圈
t.penup()
t.goto(105, 90)
t.setheading(45)
t.fillcolor("black")
t.pencolor("black")
t.begin_fill()
t.pendown()
a = 0.2
for i in range(120):
    if 0 <= i < 30 or 60 <= i < 90:
        a = a + 0.1
        t.speed(100)
        t.lt(3)  # 向左转3度
        t.fd(a)  # 向前走a的步长
    else:
        a = a - 0.1
        t.speed(100)
        t.lt(3)
        t.fd(a)
t.end_fill()
# 右眼眼白
t.fillcolor("white")
t.penup()
t.goto(73, 110)
t.setheading(0)
t.begin_fill()
t.pendown()
t.circle(14, 360)
t.end_fill()
# 右眼眼珠
t.penup()
t.goto(74, 117)
t.setheading(0)
t.begin_fill()
t.pendown()
t.circle(6, 360)
t.end_fill()

#鼻子   鼻子就简单画了下，就是一个等边三角新
t.pencolor("black")      #定义画笔颜色
t.fillcolor("black")     #定义填充颜色
t.penup()                #起笔
t.goto(-8,105)         #移动到某个位置
t.begin_fill()           #开始填充颜色
t.pendown()
t.fd(20)                 #向前移动指定距离
t.seth(-120)             #旋转角度
t.fd(20)
t.seth(120)
t.fd(20)
t.end_fill()             #结束填充颜色

# 嘴
t.penup()
t.goto(-22, 70)
t.setheading(-30)
t.fillcolor("red")
t.begin_fill()
t.pendown()
t.circle(50, 60)
t.setheading(-120)
t.circle(-100, 15)
t.circle(-15, 90)
t.circle(-100, 15)
t.end_fill()

#奥运五环
#1环
t.pensize(3)
t.pencolor("black")
t.penup()
t.goto(10,0)
t.pendown()
t.circle(20)
#2环
t.pensize(3)
t.pencolor("blue")
t.penup()
t.goto(30,0)
t.pendown()
t.circle(20)
#3环
t.pensize(3)
t.pencolor("red")
t.penup()
t.goto(0,-10)
t.pendown()
t.circle(20)
#4环
t.pensize(3)
t.pencolor("yellow")
t.penup()
t.goto(20,-10)
t.pendown()
t.circle(20)
#五环
t.pensize(3)
t.pencolor("green")
t.penup()
t.goto(40,-10)
t.pendown()
t.circle(20)

#胳膊
#右胳膊
t.pencolor("black")
t.fillcolor("black")
t.pensize(6)
t.penup()
t.goto(152,50)
t.setheading(60)
t.begin_fill()
t.pendown()
t.fd(100)
t.setheading(70)
t.circle(20, 180)
t.fd(30)
t.circle(-5, 160)
t.end_fill()

#左胳膊
t.pencolor("black")
t.fillcolor("black")
t.pensize(6)
t.penup()
t.goto(-145,30)
t.setheading(-120)
t.begin_fill()
t.pendown()
t.fd(100)
t.setheading(-110)
t.circle(20, 180)
t.fd(50)
t.circle(-5, 100)
t.end_fill()
#腿
#左腿
t.fillcolor("black")
t.penup()
t.goto(-95,-77)
t.begin_fill()
t.pendown()
t.setheading(-90)
t.circle(-140, 20)   #第一个参数为半径，第二个参数为角度
t.circle(5, 109)
t.fd(30)
t.circle(10,120)
t.setheading(90)
t.circle(-140, 10)
t.end_fill()
#右腿
t.fillcolor("black")
t.penup()
t.goto(95,-80)
t.begin_fill()
t.pendown()
t.setheading(-90)
t.circle(140, 20)   #第一个参数为半径，第二个参数为角度
t.circle(-5, 109)
t.fd(30)
t.circle(-10,120)
t.setheading(90)
t.circle(140, 10)
t.end_fill()

#冰糖外壳
t.pensize(3)
t.penup()
t.goto(-138, 147)
t.setheading(160)
t.pendown()
t.circle(-40, 200)
t.setheading(50)
t.circle(-128, 100)
t.setheading(40)
t.circle(-40, 215)

t.setheading(-60)
t.fd(25)
t.circle(2, 200)
t.setheading(65)
t.fd(45)
t.circle(-30, 180)
t.fd(100)

t.circle(2, 25)
t.circle(-200, 47)
t.circle(2, 60)
t.circle(140, 23)
t.circle(-2, 90)
t.setheading(180)
t.fd(75)
t.circle(-2, 90)
t.fd(25)
t.setheading(-160)
t.circle(-140, 60)
t.setheading(-90)
t.fd(30)


#显示图形
t.hideturtle()     #隐藏画笔的turtle形状
t.showturtle()
t.done()           #必须是乌龟图形程序中的最后一个语句。

代码还有一点没有完善，会继续改进

展开全文 >>

人工神经网络

学习及作业

简单介绍

…….

符号表示

Wab 代表结点a到结点b的权重
ya 代表结点a的输出值
Za 代表结点a的输入值
C 最终的损失函数

损失函数
$$
C=\frac{1}{2}errors^2
$$
其中errors是真实值与预测值的差值，目的是为了减少损失，从而调节参数，减少损失。

例子

数据用矩阵表示就是下面这样的
$$
输入数据：
Z_a=\begin{bmatrix}
0.35\
0.9\
\end{bmatrix}
$$

$$
权重：
w_0=\begin{bmatrix}
0.1&0.8\
0.4&0.6\
\end{bmatrix}\
\
权重:
w_1=\begin{bmatrix}
0.3&0.9\
\end{bmatrix}
$$

自然语言描述算法

1.初始化，用小的随机数给各权值和阈值赋初值。

2.读取网络参数和训练样本集。

3.数据处理，可以进行归一化（数据映射到0~1，方便统一处理）。

4.对训练集中每个样本进行计算。

①前向计算隐层、输出层各神经元的输出。

②计算期望输出与网络输出的误差。

③反向计算修正网络权值和阈值。

5.若满足精度要求或其他退出条件，则结束训练，否则转步骤4继续。

6.结果分析与输出。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import numpy as np
def nonlin(x, deriv=False):
	if deriv == True:
	    return x * (1 - x) #如果deriv为true，求导数
	return 1 / (1 + np.exp(-x))
X = np.array([[0.35],[0.9]]) #输入层y = np.array([[0.5]]) #输出值
y=np.array([[0.5]]) #定义的输出的值

W0 = np.array([[0.1,0.8],[0.4,0.6]])
W1 = np.array([[0.3,0.9]])
print("初始权值: ")
print(W0)
print(W1)

for i in range(1,10):
	l0 = X #相当于文章中x0
	l1 = np.dot(W0,l0)             #输入值与权值相乘，即矩阵相乘
	l2 = np.dot(W1,l1)
	#print(l1,l2)                  #乘积结果
	l2_error = y - l2              #真实值与预测值的差值
	#print(l2_error)
	Error = 1/2.0*(y-l2)**2        #损失函数
	l2_delta = l2_error * nonlin(l2, deriv=True) #this will backpack
	l1_error = l2_delta*W1        #反向传播
	l1_delta = l1_error * nonlin(l1, deriv=True)
	W1 += l2_delta*l1.T #修改权值
	W0 += l0.T.dot(l1_delta)
	print("第",i,"次修改后的权值: ")
	print(W0)
	print(W1)

作业

numpy的使用补充

numpy函数

函数格式 用途
np.array() 定义数组
x.shape[0] 得到矩阵的行数
x.shape[1] 得到矩阵的列数
x.reshape(N,-1) 固定行数，-1表示行数需要计算
np.dot(m,n) m和n两个矩阵的叉乘
np.sum() 求和函数
axis=0 返回按列相加的一个数组
keepdims 保持原有维度输出
np.random.randn(m,n) 随机生成一个维度位m*n的矩阵(元素大小在(0,1)之间)
np.zeros(m,n) 生成一个m*n的元素全为0的矩阵
np.maximum(0,H) 只返回(0，H)中大的元素
np.exp(x) 计算e的x次幂
np.arange(N) 生成数组
np.copy() 函数起名，copy
np.log(x) 计算以e位底的x的log值

softmax层函数

类似于归一化处理，目的是为了使输出的结果更为直观。那么我们能不能使得一系类预测值y变为相应的概率，概率大的就为输出的最终结果呢？当然可以。

简单来说分三步进行：

（1）以e为底对所有元素求指数幂；

（2）将所有指数幂求和；

（3）分别将这些指数幂与该和做商。

这样求出的结果中，一系列的和一定为1，而每个元素可以代表概率值。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import numpy as np
def affine_forward(x, w, b):   #w为传进的权值
    out = None                       # 初始化返回值为None
    N =x.shape[0]                    # 重置输入参数X的形状（重置矩阵的行数）
    x_row = x.reshape(N, -1)         # (N,D)
    out = np.dot(x_row, w) + b       # (N,M) 矩阵相乘
    cache = (x, w, b)                # 缓存值，反向传播时使用
    return out,cache
def affine_backward(dout, cache):
    x, w, b = cache                              # 读取缓存
    dx, dw, db = None, None, None                # 返回值初始化
    dx = np.dot(dout, w.T)                       # (N,D)
    dx = np.reshape(dx, x.shape)                 # (N,d1,...,d_k)
    x_row = x.reshape(x.shape[0], -1)            # (N,D)
    dw = np.dot(x_row.T, dout)                   # (D,M)
    db = np.sum(dout, axis=0, keepdims=True)     # (1,M)
    return dx, dw, db
X = np.array([[2,1],
            [-1,1],
            [-1,-1],
            [1,-1]])      # 用于训练的坐标，对应的是I、II、III、IV象限
t = np.array([0,1,2,3])   # 标签，对应的是I、II、III、IV象限
np.random.seed(1)         # 有这行语句，你们生成的随机数就和我一样了
# 一些初始化参数
input_dim = X.shape[1]     # 输入参数的维度，此处为2，即每个坐标用两个数表示 得到矩阵的列数
num_classes = t.shape[0]   # 输出参数的维度，此处为4，即最终分为四个象限     得到矩阵的行数
hidden_dim = 50            # 隐藏层维度，为可调参数
reg = 0.001                # 正则化强度，为可调参数
epsilon = 0.001            # 梯度下降的学习率，为可调参数
# 初始化W1，W2，b1，b2
W1 = np.random.randn(input_dim, hidden_dim)     # (2,50)
W2 = np.random.randn(hidden_dim, num_classes)   # (50,4)
b1 = np.zeros((1, hidden_dim))                  # (1,50)
b2 = np.zeros((1, num_classes))                 # (1,4)
for j in range(10000):   #这里设置了训练的循环次数为10000
 # ①前向传播
    H,fc_cache = affine_forward(X,W1,b1)                 # 第一层前向传播
    H = np.maximum(0, H)                                 # 激活 H为最大值
    relu_cache = H                                       # 缓存第一层激活后的结果
    Y,cachey = affine_forward(H,W2,b2)                   # 第二层前向传播
 # ②Softmax层计算
    probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
    probs /= np.sum(probs, axis=1, keepdims=True)        # Softmax算法实现
 # ③计算loss值
    N = Y.shape[0]                                       # 值为4 行数
    print(probs[np.arange(N), t])                        # 打印各个数据的正确解标签对应的神经网络的输出
    loss = -np.sum(np.log(probs[np.arange(N), t])) / N   # 计算loss
    print(loss)                                          # 打印loss
 # ④反向传播
    dx = probs.copy()                                    # 以Softmax输出结果作为反向输出的起点
    dx[np.arange(N), t] -= 1
    dx /= N                                              # 到这里是反向传播到softmax前
    dh1, dW2, db2 = affine_backward(dx, cachey)          # 反向传播至第二层前
    dh1[relu_cache <= 0] = 0                             # 反向传播至激活层前
    dX, dW1, db1 = affine_backward(dh1, fc_cache)        # 反向传播至第一层前
# ⑤参数更新
    dW2 += reg * W2
    dW1 += reg * W1
    W2 += -epsilon * dW2
    b2 += -epsilon * db2
    W1 += -epsilon * dW1
    b1 += -epsilon * db1
test = np.array([[2,2],[-2,2],[-2,-2],[2,-2]])
H,fc_cache = affine_forward(test,W1,b1)               #仿射
H = np.maximum(0, H)                                  #激活
relu_cache = H
Y,cachey = affine_forward(H,W2,b2)  #仿射
 # Softmax
probs = np.exp(Y - np.max(Y, axis=1, keepdims=True))
probs /= np.sum(probs, axis=1, keepdims=True)  # Softmax
print(probs)
for k in range(4):
    print(test[k,:],"所在的象限为",np.argmax(probs[k,:])+1)

展开全文 >>

多态代码实例

计算器类

目的是为了说明运用多态抒写代码的好处

首先我们先用类写一个普通的

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<iostream>
#include<iostream>
using namespace std;
//利用普通写法和多态来进行运算的计算器 

//1.普通写法 
class calculator
{
public:
	int function(string oper)
	{
		if(oper=="+")
		{
			return m_A+m_B;
		}
		else if(oper=="-")
		{
			return m_A-m_B;
		}
		else if(oper=="*")
		{
			return m_A*m_B;
		}
		else
		{
			if(m_B!=0)
			 return m_A/m_B;
		}
	}
public:
	int m_A;
	int m_B;
};

void test()
{
	calculator c; 
	c.m_A=20;
	c.m_B=15;
	cout<<"m_A+m_B= "<<c.function("+")<<endl;
	cout<<"m_A-m_B= "<<c.function("-")<<endl;
	cout<<"m_A*m_B= "<<c.function("*")<<endl;
	cout<<"m_A/m_B= "<<c.function("/")<<endl;
}
int main()
{
	test();
	system("pause");
	return 0;
	
}

对于普通的代码，我们如果想修改某部分的内容的话，不是很方便，所以下面我们用多态来写

多态的好处：

1.可读性强

2.组织结构清晰

3.对于前期和后期扩展以及维护性高

多态代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include<iostream>
#include<iostream>
using namespace std;
//多态写法

//计算器类 
class Calculator
{
public:
	virtual int GetResult()
	{
		
	} 
public:
	int m_A;
	int m_B;
};
//计算器加法子类
class AddCalculator:public Calculator
{
	int GetResult()
	{
		return m_A+m_B;
	}
};
//计算器减法子类
class  SubCalculator:public Calculator
{
	int GetResult()
	{
		return m_A-m_B;
	}
};
//计算器乘法子类
class MulCalculator:public Calculator
{
	int GetResult()
	{
		return m_A*m_B;
	}
};
//测试函数 
void test()
{
	//多态的使用条件：父类指针或者引用指向子类对象 
	Calculator *c=new AddCalculator;
	c->m_A=15;
	c->m_B=30;
	cout<<"m_A+m_B= "<<c->GetResult()<<endl;
	delete c; 
	
	c=new SubCalculator;
	c->m_A=15;
	c->m_B=30;
	cout<<"m_A-m_B= "<<c->GetResult()<<endl;
	delete c; 
	
	c=new MulCalculator;
	c->m_A=15;
	c->m_B=30;
	cout<<"m_A*m_B= "<<c->GetResult()<<endl;
	delete c; 
}
int main()
{
	test();
	system("pause");
	return 0;
	
}

制作饮品类

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include<iostream>
#include<string.h>
using namespace std;
//多态案例2-制作饮料 
class AbstractDrinking 
{
public:
	//煮水
	virtual void Boid()=0;
	//冲泡
	virtual void Brew()=0;
	//倒入杯中
	virtual void PourInCup()=0;
	//加入辅料
	virtual void PutSomething()=0;
	//制作饮料
    void MakeDrink()
	{
		Boid();
		Brew();
		PourInCup();
		PutSomething();
	}
};
//子类1 制作咖啡 
class Coffe:public AbstractDrinking
{
	//煮水
	virtual void Boid()
	{
		cout<<"烧开水"<<endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout<<"冲泡咖啡"<<endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout<<"咖啡倒入杯中"<<endl; 
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout<<"加入红糖"<<endl;
	}
};

//子类2 制作咖啡 
class Tea:public AbstractDrinking
{
	//煮水
	virtual void Boid()
	{
		cout<<"烧开水"<<endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout<<"冲泡茶叶"<<endl;
	}
	//倒入杯中
	virtual void PourInCup()
	{
		cout<<"茶叶倒入杯中"<<endl; 
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout<<"加入柠檬"<<endl;
	}
};
void DoWork(AbstractDrinking *abc)
{
	abc->MakeDrink();
	delete abc;       //对堆区开辟数据进行释放 
} 
void test()
{
	DoWork(new Tea);
	cout<<"--------------------"<<endl;
	DoWork(new Coffe);
}
int main()
{
	test();
	system("pause");
	return 0;
}

电脑类

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
#include<iostream>
#include<string.h>
using namespace std;
//抽象出每个零件的类 

class CPU
{
public:
	//抽象计算函数
	virtual void Calculate()=0; //纯虚函数 
};
class VideoCard
{
public:
	//抽象显示函数
	virtual void Display()=0;  //纯虚函数 
};
class Memory
{
public:
	//抽象存储函数
	virtual void Storage()=0;  //纯虚函数 
};

//抽象电脑类
class Computer
{
public:
	Computer(CPU *cpu,VideoCard *vc,Memory *mem)
	{
		m_cpu=cpu;
		m_vc=vc;
		m_mem=mem;
	}
	//工作函数 
	void DoWork()
	{
		//通过变量定义来调用 
		m_cpu->Calculate();
		m_vc->Display();
		m_mem->Storage(); 
	}
	//析构函数
	~Computer()
	{
		if(m_cpu!=NULL)
		{
			delete m_cpu;
			m_cpu=NULL;
		}
			if(m_vc!=NULL)
		{
			delete m_vc;
			m_vc=NULL;
		}
		if(m_mem!=NULL)
		{
			delete m_mem;
			m_mem=NULL;
		}
	} 
private:
	CPU *m_cpu;
	VideoCard *m_vc;
	Memory *m_mem;
};

//具体厂商生产
//inter
class InterCpu:public CPU
{
public:
	virtual void Calculate()
	{
		cout<<"Inter的CPU开始计算！！！"<<endl;
	}
}; 
class InterVideoCard:public VideoCard
{
public:
	virtual void Display()
	{
		cout<<"Inter的Card开始显示！！！"<<endl;
	}
}; 
class InterMemory:public Memory
{
public:
	virtual void Storage()
	{
		cout<<"Inter的mem开始储存！！！"<<endl;
	}
}; 

//lenovo
class LenovoCpu:public CPU
{
public:
	virtual void Calculate()
	{
		cout<<"Lenovo的CPU开始计算！！！"<<endl;
	}
}; 
class LenovoVideoCard:public VideoCard
{
public:
	virtual void Display()
	{
		cout<<"Lenovo的Card开始显示！！！"<<endl;
	}
}; 
class LenovoMemory:public Memory
{
public:
	virtual void Storage()
	{
		cout<<"Lenovo的mem开始储存！！！"<<endl;
	}
}; 
//Inter电脑 
void test1()
{
	//创建第一台电脑零件
	CPU *intercpu=new InterCpu;
	VideoCard *intercard=new InterVideoCard;
	Memory *intermem=new InterMemory;
	//创建第一台电脑
	Computer *computer1=new Computer(intercpu,intercard,intermem);
	computer1->DoWork();
	delete computer1;
}
//Lenovo电脑 
void test2()
{
	//第二台电脑
	CPU *lenovocpu=new LenovoCpu;
	VideoCard *lenovocard=new LenovoVideoCard;
	Memory *lenovomem=new LenovoMemory;
	
	Computer *computer2=new Computer(lenovocpu,lenovocard,lenovomem);
	computer2->DoWork();
	delete computer2;
}
//二者组合电脑
void test3()
{
	CPU *intercpu=new InterCpu;
	VideoCard *lenovocard=new LenovoVideoCard;
	Memory *lenovomem=new LenovoMemory;
	
	Computer *computer2=new Computer(intercpu,lenovocard,lenovomem);
	computer2->DoWork();
	delete computer2;
}
int main()
{
	//test1();
	//test2();
	test3();
	system("pause");
	return 0;
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

生活不止眼前的苟且,还有诗和远方的田野. WeChat：gyh2219608739 就读学校：河南理工