Commit cc58c2f9e0957f1a2aaa2b4ad069864647dda443 - luxu1011578034644 - (('Mo Repos',), {'htdigest_file': None, 'use_smarthttp': 0, 'require_browser_auth': 0, 'disable_push': 0, 'unauthenticated_push': 0, 'ctags

joyvan 6 years ago

3 changed file(s) with 295 addition(s) and 160 deletion(s). Raw diff Collapse all Expand all

+114

-142

01.03 机器学习常用的包.ipynb less more

81	81	"\|ndarray.shape\|\t数组维度的元组\|\n",
82	82	"\|ndarray.ndim\|\t数组维数\|\n",
83	83	"\|ndarray.size\|\t数组中的元素数量\|\n",
84		"\|ndarray.itemsize\|\t一个数组元素的长度（字节）\|\n",
85	84	"\|ndarray.dtype\|\t数组元素的类型\|\n",
86	85	"\n",
87	86	"\n",

104	103	"import numpy as np\n",
105	104	"\n",
106	105	"# 创建不同形状的数组\n",
107		"# 创建不同形状的数组\n",
108		"a = np.array([[1,2,3],[4,5,6]])\n",
109		"b = np.array([1,2,3,4])\n",
110		"c = np.array([\n",
111		" [\n",
112		" [1,2,3],[4,5,6]\n",
113		" ],\n",
114		" [\n",
115		" [1,2,3],[4,5,6]\n",
116		" ]\n",
117		"])\n",
	106	"a = np.array([[1, 2, 3],[4, 5, 6]])\n",
	107	"b = np.array([1, 2, 3, 4])\n",
	108	"c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n",
118	109	"\n",
119	110	"# 分别打印出形状\n",
120	111	"print(a.shape)\n",

138	129	"import numpy as np\n",
139	130	"\n",
140	131	"# 创建不同形状的数组\n",
141		"a = np.array([[1,2,3],[4,5,6]])\n",
142		"b = np.array([1,2,3,4])\n",
143		"c = np.array([[[1,2,3],[4,5,6]], [[1,2,3],[4,5,6]]])\n",
	132	"a = np.array([[1, 2, 3],[4, 5, 6]])\n",
	133	"b = np.array([1, 2, 3, 4])\n",
	134	"c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n",
144	135	"\n",
145	136	"# 分别打印出维数\n",
146	137	"print(a.ndim)\n",

164	155	"import numpy as np\n",
165	156	"\n",
166	157	"# 创建不同形状的数组\n",
167		"a = np.array([[1,2,3],[4,5,6]])\n",
168		"b = np.array([1,2,3,4])\n",
169		"c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])\n",
	158	"a = np.array([[1, 2, 3],[4, 5, 6]])\n",
	159	"b = np.array([1, 2, 3, 4])\n",
	160	"c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n",
170	161	"\n",
171	162	"# 分别打印出数组元素数量\n",
172	163	"print(a.size)\n",

178	169	"cell_type": "markdown",
179	170	"metadata": {},
180	171	"source": [
181		"+ `itemsize`：数组元素的长度"
	172	"+ `dtype`：数组元素的类型"
182	173	]
183	174	},
184	175	{

190	181	"import numpy as np\n",
191	182	"\n",
192	183	"# 创建不同形状的数组\n",
193		"a = np.array([[1,2,3],[4,5,6]])\n",
194		"b = np.array([1,2,3,4])\n",
195		"c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,60]]])\n",
196		"\n",
197		"# 分别打印出数组元素数量\n",
198		"print(a.itemsize)\n",
199		"print(b.itemsize)\n",
200		"print(c.itemsize)\n"
201		]
202		},
203		{
204		"cell_type": "markdown",
205		"metadata": {},
206		"source": [
207		"+ `dtype`：数组元素的类型"
208		]
209		},
210		{
211		"cell_type": "code",
212		"execution_count": null,
213		"metadata": {},
214		"outputs": [],
215		"source": [
216		"import numpy as np\n",
217		"\n",
218		"# 创建不同形状的数组\n",
219		"a = np.array([[1,2,3],[4,5,6]])\n",
220		"b = np.array([1,2,3,4])\n",
221		"c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6.0]]])\n",
	184	"a = np.array([[1, 2, 3],[4, 5, 6]])\n",
	185	"b = np.array([1, 2, 3, 4])\n",
	186	"c = np.array([[[1, 2, 3],[4, 5, 6]],[[1, 2, 3],[4, 5, 6.0]]])\n",
222	187	"\n",
223	188	"# 分别打印出数组元素数量\n",
224	189	"print(a.dtype)\n",

232	197	"source": [
233	198	"### `ndarray` 的类型\n",
234	199	"\n",
235		"\|名称\|\t描述\|\t简写\|\n",
	200	"\|名称\|\t描述\|\n",
236	201	"\|--\|--\|--\|\n",
237		"\|np.bool\|\t用一个字节存储的布尔类型（True或False）\|\t'b'\|\n",
238		"\|np.int8\|\t一个字节大小，-128 至 127\|\t'i'\|\n",
239		"\|np.int16\|\t整数，-32768 至 32767\|\t'i2'\|\n",
240		"\|np.int32\|\t整数，$-2^{31}$ 至 $2^{32} -1$\t\|'i4'\|\n",
241		"\|np.int64\|\t整数，$-2^{63}$ 至 $2^{63} - 1$\t\|'i8'\|\n",
242		"\|np.uint8\|\t无符号整数，0 至 255\|\t'u'\|\n",
243		"\|np.uint16\t\|无符号整数，0 至 65535\|\t'u2'\|\n",
244		"\|np.uint32\|\t无符号整数，0 至 $2^{32} - 1$\t\|'u4'\|\n",
245		"\|np.uint64\|\t无符号整数，0 至 $2^{64} - 1$ \|'u8'\|\n",
246		"\|np.float16\t\|半精度浮点数：16位，正负号1位，指数5位，精度10位\t\|'f2'\|\n",
247		"\|np.float32\t\|单精度浮点数：32位，正负号1位，指数8位，精度23位\t\|'f4'\|\n",
248		"\|np.float64\t\|双精度浮点数：64位，正负号1位，指数11位，精度52位\t\|'f8'\|\n",
249		"\|np.complex64\t\|复数，分别用两个32位浮点数表示实部和虚部\t\|'c8'\|\n",
250		"\|np.complex128\t\|复数，分别用两个64位浮点数表示实部和虚部\t\|'c16'\|\n",
251		"\|np.object_\t\|python对象\t\|'O'\|\n",
252		"\|np.string_\t\|字符串\t\|'S'\|\n",
253		"\|np.unicode_\t\|unicode类型\t\|'U'\|\n",
	202	"\|np.bool\|\t用一个字节存储的布尔类型（True或False）\|\n",
	203	"\|np.int8\|\t一个字节大小，-128 至 127\|\n",
	204	"\|np.int16\|\t整数，-32768 至 32767\|\n",
	205	"\|np.int32\|\t整数，$-2^{31}$ 至 $2^{32} -1$\t\|\n",
	206	"\|np.int64\|\t整数，$-2^{63}$ 至 $2^{63} - 1$\t\|\n",
	207	"\|np.uint8\|\t无符号整数，0 至 255\|\n",
	208	"\|np.uint16\t\|无符号整数，0 至 65535\|\n",
	209	"\|np.uint32\|\t无符号整数，0 至 $2^{32} - 1$\t\|\n",
	210	"\|np.uint64\|\t无符号整数，0 至 $2^{64} - 1$ \|\n",
	211	"\|np.float16\t\|半精度浮点数：16位，正负号1位，指数5位，精度10位\t\|\n",
	212	"\|np.float32\t\|单精度浮点数：32位，正负号1位，指数8位，精度23位\t\|\n",
	213	"\|np.float64\t\|双精度浮点数：64位，正负号1位，指数11位，精度52位\t\|\n",
	214	"\|np.complex64\t\|复数，分别用两个32位浮点数表示实部和虚部\t\|\n",
	215	"\|np.complex128\t\|复数，分别用两个64位浮点数表示实部和虚部\t\|\n",
	216	"\|np.object_\t\|python对象\t\|\n",
	217	"\|np.string_\t\|字符串\t\|\n",
	218	"\|np.unicode_\t\|unicode类型\t\|\n",
254	219	"\n",
255	220	"注意：创建数组的时候指定类型"
256	221	]

285	250	"cell_type": "markdown",
286	251	"metadata": {},
287	252	"source": [
288		"#### 生成 `0 ` 和 `1` 数组的常见方法 \n",
289		"\n",
290		"+ 生成 `0` 的数组"
	253	"#### 生成元素值为 `0 ` 和 `1` 的数组的方法 \n",
	254	"\n",
	255	"+ 生成全部元素值为 `0` 的数组"
291	256	]
292	257	},
293	258	{

306	271	"cell_type": "markdown",
307	272	"metadata": {},
308	273	"source": [
309		"+ 生成 `1` 的数组"
310		]
311		},
312		{
313		"cell_type": "code",
314		"execution_count": null,
315		"metadata": {},
316		"outputs": [],
317		"source": [
318		"one = np.ones([3,4])\n",
	274	"+ 生成全部元素值为 `1` 的数组"
	275	]
	276	},
	277	{
	278	"cell_type": "code",
	279	"execution_count": null,
	280	"metadata": {},
	281	"outputs": [],
	282	"source": [
	283	"one = np.ones([3, 4])\n",
319	284	"one\n"
320	285	]
321	286	},

332	297	"metadata": {},
333	298	"outputs": [],
334	299	"source": [
335		"eyes = np.eye(10,5)\n",
	300	"eyes = np.eye(10, 5)\n",
336	301	"eyes\n"
337	302	]
338	303	},

349	314	"metadata": {},
350	315	"outputs": [],
351	316	"source": [
352		"# np.eye（）输入数据相等则是方阵\n",
	317	"# np.eye(5, 5) 可简写为 (5)\n",
353	318	"eyes1 = np.eye(5)\n",
354	319	"eyes1\n"
355	320	]

367	332	"metadata": {},
368	333	"outputs": [],
369	334	"source": [
370		"a = [[1,2,3],[4,5,6]]\n",
371		"\n",
372		"# 从现有的数组当中创建\n",
	335	"a = [[1, 2, 3], [4, 5, 6]]\n",
	336	"\n",
	337	"# 从现有的数组中创建\n",
373	338	"a1 = np.array(a)\n",
374	339	"a\n"
375	340	]

441	406	"source": [
442	407	"# 在转换形状的时候，一定要注意数组的元素匹配\n",
443	408	"# 只是将形状进行了修改，但并没有将行列进行转换\n",
444		"b = a.reshape([3,8])\n",
	409	"b = a.reshape([3, 8])\n",
445	410	"b\n"
446	411	]
447	412	},

451	416	"metadata": {},
452	417	"outputs": [],
453	418	"source": [
454		"# 数组的形状被修改为: (2, 12), -1: 表示通过待计算\n",
455		"c = a.reshape([-1,12])\n",
	419	"# 数组的形状被修改为: (2, 12), -1: 表示同过自动计算得到此处的值\n",
	420	"c = a.reshape([-1, 12])\n",
456	421	"c\n"
457	422	]
458	423	},

541	506	"outputs": [],
542	507	"source": [
543	508	"import numpy as np\n",
544		"a = np.array([1,2,3,4])\n",
	509	"a = np.array([1, 2, 3, 4])\n",
545	510	"a * 3\n"
546	511	]
547	512	},

549	514	"cell_type": "markdown",
550	515	"metadata": {},
551	516	"source": [
552		"数组逐元素相乘："
553		]
554		},
555		{
556		"cell_type": "code",
557		"execution_count": null,
558		"metadata": {},
559		"outputs": [],
560		"source": [
561		"a = np.array([1,2])\n",
562		"b = np.array([3,4])\n",
	517	"数组按元素相乘："
	518	]
	519	},
	520	{
	521	"cell_type": "code",
	522	"execution_count": null,
	523	"metadata": {},
	524	"outputs": [],
	525	"source": [
	526	"a = np.array([1, 2])\n",
	527	"b = np.array([3, 4])\n",
563	528	"a * b\n"
564	529	]
565	530	},

619	584	"outputs": [],
620	585	"source": [
621	586	"import numpy as np\n",
622		"a = np.array([[1,2,4],\n",
623		" [2,5,3],\n",
624		" [7,8,9]])\n",
	587	"a = np.array([[1, 2, 4],\n",
	588	" [2, 5, 3],\n",
	589	" [7, 8, 9]])\n",
625	590	"A = np.mat(a)\n",
626	591	"A\n"
627	592	]

669	634	"metadata": {},
670	635	"outputs": [],
671	636	"source": [
672		"b = np.array([[1,2],\n",
673		" [3,4],\n",
674		" [5,6]])\n",
	637	"b = np.array([[1, 2],\n",
	638	" [3, 4],\n",
	639	" [5, 6]])\n",
675	640	"B = np.mat(b)\n",
676	641	"A*B\n"
677	642	]

742	707	"outputs": [],
743	708	"source": [
744	709	"from numpy import array\n",
745		"a = array([[1,2,3],\n",
746		" [4,5,6]])\n",
	710	"a = array([[1, 2, 3],\n",
	711	" [4, 5, 6]])\n",
747	712	"a\n"
748	713	]
749	714	},

901	866	"cell_type": "markdown",
902	867	"metadata": {},
903	868	"source": [
904		"但是当数组元素较多时，查看输出结果便变得很麻烦，这时我们可以使用`all（）`方法，直接比对矩阵的所有对应的元素是否满足条件。假如判断某个区间的值是否全是大于 `20`:"
	869	"但是当数组元素较多时，查看输出结果便变得很麻烦，这时我们可以使用`all()`方法，直接比对矩阵的所有对应的元素是否满足条件。假如判断某个区间的值是否全是大于 `20`:"
905	870	]
906	871	},
907	872	{

925	890	"metadata": {},
926	891	"outputs": [],
927	892	"source": [
928		"np.all(a[1:4,1:3] > 20)\n"
929		]
930		},
931		{
932		"cell_type": "markdown",
933		"metadata": {},
934		"source": [
935		"比如判断数组某个区间的元素是否存在大于 `20`的元素:"
936		]
937		},
938		{
939		"cell_type": "code",
940		"execution_count": null,
941		"metadata": {},
942		"outputs": [],
943		"source": [
944		"np.any(a[1:4,1:3] > 20)\n"
	893	"np.all(a[1:3,1:3] > 20)\n"
	894	]
	895	},
	896	{
	897	"cell_type": "markdown",
	898	"metadata": {},
	899	"source": [
	900	"使用 `any()` 来判断数组某个区间的元素是否存在大于 `20`的元素:"
	901	]
	902	},
	903	{
	904	"cell_type": "code",
	905	"execution_count": null,
	906	"metadata": {},
	907	"outputs": [],
	908	"source": [
	909	"np.any(a[1:3,1:3] > 20)\n"
945	910	]
946	911	},
947	912	{

960	925	},
961	926	{
962	927	"cell_type": "code",
963		"execution_count": 2,
	928	"execution_count": null,
964	929	"metadata": {},
965	930	"outputs": [],
966	931	"source": [
967	932	"import numpy as np\n",
968	933	"\n",
969		"data = np.array([[1,2],\n",
970		" [3,4]])\n",
	934	"data = np.array([[1, 2],\n",
	935	" [3, 4]])\n",
971	936	"\n",
972	937	"# 保存文件\n",
973	938	"np.savetxt('out.txt', data)\n"

1535	1500	"\n",
1536	1501	"+ 常用的回归：线性、决策树、`SVM`、`KNN` ； \n",
1537	1502	" 集成回归：随机森林、`Adaboost`、`GradientBoosting`、`Bagging`、`ExtraTrees` \n",
1538		"+ 常用的分类：线性、决策树、`SVM`、`KNN`，朴素贝叶斯； \n",
	1503	"+ 常用的分类：线性、决策树、`SVM`、`KNN`、朴素贝叶斯； \n",
1539	1504	" 集成分类：随机森林、`Adaboost`、`GradientBoosting`、`Bagging`、`ExtraTrees` \n",
1540	1505	"+ 常用聚类：`k` 均值（`K-means`）、层次聚类（`Hierarchical clustering`）、`DBSCAN` \n",
1541	1506	"+ 常用降维：`LinearDiscriminantAnalysis`、`PCA` 　　\n",

1606	1571	"# 获取鸢尾花数据集\n",
1607	1572	"iris = load_iris()\n",
1608	1573	"\n",
1609		"# 获得ndarray格式的变量X和标签y\n",
	1574	"# 获得 ndarray 格式的变量 X 和标签 y\n",
1610	1575	"X = iris.data\n",
1611	1576	"y = iris.target\n",
1612	1577	"\n",

1641	1606	"sc = MinMaxScaler()\n",
1642	1607	"sc.fit(X)\n",
1643	1608	"results = sc.transform(X)\n",
1644		"print(\"放缩前：\",X[1])\n",
1645		"print(\"放缩后：\",results[1])\n"
	1609	"print(\"放缩前：\", X[1])\n",
	1610	"print(\"放缩后：\", results[1])\n"
1646	1611	]
1647	1612	},
1648	1613	{

1666	1631	"#将fit和transform组合执行\n",
1667	1632	"results = StandardScaler().fit_transform(X) \n",
1668	1633	"\n",
1669		"print(\"放缩前：\",X[1])\n",
1670		"print(\"放缩后：\",results[1])"
	1634	"print(\"放缩前：\", X[1])\n",
	1635	"print(\"放缩后：\", results[1])"
1671	1636	]
1672	1637	},
1673	1638	{

1690	1655	"\n",
1691	1656	"results = Normalizer().fit_transform(X)\n",
1692	1657	"\n",
1693		"print(\"放缩前：\",X[1])\n",
1694		"print(\"放缩后：\",results[1])"
	1658	"print(\"放缩前：\", X[1])\n",
	1659	"print(\"放缩后：\", results[1])"
1695	1660	]
1696	1661	},
1697	1662	{

1714	1679	"\n",
1715	1680	"results = Binarizer(threshold=3).fit_transform(X)\n",
1716	1681	"\n",
1717		"print(\"处理前：\",X[1])\n",
1718		"print(\"处理后：\",results[1])"
	1682	"print(\"处理前：\", X[1])\n",
	1683	"print(\"处理后：\", results[1])"
1719	1684	]
1720	1685	},
1721	1686	{

1735	1700	"source": [
1736	1701	"# 标签编码\n",
1737	1702	"from sklearn.preprocessing import LabelEncoder\n",
1738		"LabelEncoder().fit_transform(['apple','pear','orange','banana'])"
	1703	"LabelEncoder().fit_transform(['apple', 'pear', 'orange', 'banana'])"
1739	1704	]
1740	1705	},
1741	1706	{

1758	1723	"\n",
1759	1724	"results = OneHotEncoder().fit_transform(y.reshape(-1,1)).toarray()\n",
1760	1725	"\n",
1761		"print(\"处理前：\",X[1])\n",
1762		"print(\"处理后：\",results[1])\n"
	1726	"print(\"处理前：\", X[1])\n",
	1727	"print(\"处理后：\", results[1])\n"
1763	1728	]
1764	1729	},
1765	1730	{

2048	2013	"outputs": [],
2049	2014	"source": [
2050	2015	"from sklearn.model_selection import train_test_split\n",
2051		"X_train,X_test,Y_train,Y_test = train_test_split(X, y, test_size=0.1, random_state=0)\n"
	2016	"X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=0.1, random_state=0)\n"
2052	2017	]
2053	2018	},
2054	2019	{

2148	2113	"print(\"\\n交叉验证的准确率:\",np.round(scores,2)) # 打印输出每次迭代的度量值（准确度）\n",
2149	2114	"print(\"\\n交叉验证结果的置信区间: %0.2f%%(+/- %0.2f)\" % (scores.mean()100, scores.std() 2)) # 获取置信区间。（也就是均值和方差）\n"
2150	2115	]
	2116	},
	2117	{
	2118	"cell_type": "code",
	2119	"execution_count": null,
	2120	"metadata": {},
	2121	"outputs": [],
	2122	"source": []
2151	2123	}
2152	2124	],
2153	2125	"metadata": {

+165

-18

01.04 Keras MNIST Playground.ipynb less more

144	144	},
145	145	{
146	146	"cell_type": "code",
147		"execution_count": null,
148		"metadata": {},
149		"outputs": [],
	147	"execution_count": 1,
	148	"metadata": {},
	149	"outputs": [
	150	{
	151	"name": "stderr",
	152	"output_type": "stream",
	153	"text": [
	154	"Using TensorFlow backend.\n"
	155	]
	156	}
	157	],
150	158	"source": [
151	159	"# 导入必要的包\n",
152	160	"\n",

186	194	},
187	195	{
188	196	"cell_type": "code",
189		"execution_count": null,
	197	"execution_count": 2,
190	198	"metadata": {},
191	199	"outputs": [],
192	200	"source": [

320	328	},
321	329	{
322	330	"cell_type": "code",
323		"execution_count": null,
324		"metadata": {},
325		"outputs": [],
	331	"execution_count": 3,
	332	"metadata": {},
	333	"outputs": [
	334	{
	335	"data": {
	336	"image/png": "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\n",
	337	"text/plain": [
	338	"<Figure size 360x360 with 9 Axes>"
	339	]
	340	},
	341	"metadata": {
	342	"needs_background": "light"
	343	},
	344	"output_type": "display_data"
	345	}
	346	],
326	347	"source": [
327	348	"# 查看原始图片\n",
328	349	"mnist_data = MNIST()\n",

345	366	},
346	367	{
347	368	"cell_type": "code",
348		"execution_count": null,
349		"metadata": {},
350		"outputs": [],
	369	"execution_count": 4,
	370	"metadata": {},
	371	"outputs": [
	372	{
	373	"data": {
	374	"image/png": "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\n",
	375	"text/plain": [
	376	"<Figure size 360x360 with 9 Axes>"
	377	]
	378	},
	379	"metadata": {
	380	"needs_background": "light"
	381	},
	382	"output_type": "display_data"
	383	}
	384	],
351	385	"source": [
352	386	"mnist_data.update_noise(0.2)\n",
353	387	"mnist_data.update_rotation(15)\n",

365	399	},
366	400	{
367	401	"cell_type": "code",
368		"execution_count": null,
	402	"execution_count": 5,
369	403	"metadata": {},
370	404	"outputs": [],
371	405	"source": [

469	503	},
470	504	{
471	505	"cell_type": "code",
472		"execution_count": null,
	506	"execution_count": 6,
473	507	"metadata": {},
474	508	"outputs": [],
475	509	"source": [

542	576	},
543	577	{
544	578	"cell_type": "code",
545		"execution_count": null,
546		"metadata": {},
547		"outputs": [],
	579	"execution_count": 8,
	580	"metadata": {},
	581	"outputs": [
	582	{
	583	"data": {
	584	"application/vnd.jupyter.widget-view+json": {
	585	"model_id": "559c47cc65364e4f97874c93b7e65cc5",
	586	"version_major": 2,
	587	"version_minor": 0
	588	},
	589	"text/plain": [
	590	"HTML(value='<h1>准备数据</h1>', placeholder='')"
	591	]
	592	},
	593	"metadata": {},
	594	"output_type": "display_data"
	595	},
	596	{
	597	"data": {
	598	"application/vnd.jupyter.widget-view+json": {
	599	"model_id": "1000c4767996473db1877811019400be",
	600	"version_major": 2,
	601	"version_minor": 0
	602	},
	603	"text/plain": [
	604	"HBox(children=(VBox(children=(FloatSlider(value=0.0, continuous_update=False, description='每个 batch 内增强图片的比例:'…"
	605	]
	606	},
	607	"metadata": {},
	608	"output_type": "display_data"
	609	},
	610	{
	611	"data": {
	612	"application/vnd.jupyter.widget-view+json": {
	613	"model_id": "dae8559b95e8486dabf723c5878bb327",
	614	"version_major": 2,
	615	"version_minor": 0
	616	},
	617	"text/plain": [
	618	"HTML(value='<h1>构建模型</h1>', placeholder='')"
	619	]
	620	},
	621	"metadata": {},
	622	"output_type": "display_data"
	623	},
	624	{
	625	"data": {
	626	"application/vnd.jupyter.widget-view+json": {
	627	"model_id": "8ae28cfd09914c0a9282f745f1ef5f26",
	628	"version_major": 2,
	629	"version_minor": 0
	630	},
	631	"text/plain": [
	632	"HBox(children=(VBox(children=(IntSlider(value=1, description='隐藏层数目:', layout=Layout(width='400px'), max=3, st…"
	633	]
	634	},
	635	"metadata": {},
	636	"output_type": "display_data"
	637	},
	638	{
	639	"data": {
	640	"application/vnd.jupyter.widget-view+json": {
	641	"model_id": "3005c0649f8c4eafaf8e913ceb471ab0",
	642	"version_major": 2,
	643	"version_minor": 0
	644	},
	645	"text/plain": [
	646	"HTML(value='<h1>训练模型</h1>', placeholder='')"
	647	]
	648	},
	649	"metadata": {},
	650	"output_type": "display_data"
	651	},
	652	{
	653	"data": {
	654	"application/vnd.jupyter.widget-view+json": {
	655	"model_id": "99a3202d416d4da4a7aa7e0c697d3c64",
	656	"version_major": 2,
	657	"version_minor": 0
	658	},
	659	"text/plain": [
	660	"SelectionSlider(continuous_update=False, description='训练轮数:', layout=Layout(width='400px'), options=(5, 10, 20…"
	661	]
	662	},
	663	"metadata": {},
	664	"output_type": "display_data"
	665	},
	666	{
	667	"data": {
	668	"application/vnd.jupyter.widget-view+json": {
	669	"model_id": "52cc57915d66417e85e7e5a818a4e673",
	670	"version_major": 2,
	671	"version_minor": 0
	672	},
	673	"text/plain": [
	674	"Button(button_style='info', description='开始训练', style=ButtonStyle(), tooltip='点击开始训练')"
	675	]
	676	},
	677	"metadata": {},
	678	"output_type": "display_data"
	679	},
	680	{
	681	"data": {
	682	"application/vnd.jupyter.widget-view+json": {
	683	"model_id": "58a2632a35bd4b5dbb20c5884ddcfab2",
	684	"version_major": 2,
	685	"version_minor": 0
	686	},
	687	"text/plain": [
	688	"Output()"
	689	]
	690	},
	691	"metadata": {},
	692	"output_type": "display_data"
	693	}
	694	],
548	695	"source": [
549	696	"mlp = NN()\n",
550	697	"mlp.build_model()\n",

623	770	"\n",
624	771	"def plot_sample_data():\n",
625	772	" mnist_data.plot_images(show=False)\n",
626		" file = open(\"data_sample.jpg\", \"rb\")\n",
	773	" file = open(\"data_sample.png\", \"rb\")\n",
627	774	" image = file.read()\n",
628	775	" show_data_sample_widget.value = image\n",
629	776	"\n",

645	792	"\n",
646	793	"show_data_sample_widget = Image(\n",
647	794	" value=b'',\n",
648		" format='jpg',\n",
	795	" format='png',\n",
649	796	" width=200,\n",
650	797	")\n",
651	798	"\n",

666	813	" keras.backend.clear_session()\n",
667	814	" mlp.build_model()\n",
668	815	" mlp.plot_model()\n",
669		" file = open(\"model.jpg\", \"rb\")\n",
	816	" file = open(\"model.png\", \"rb\")\n",
670	817	" image = file.read()\n",
671	818	" show_model_widget.value = image\n",
672	819	"\n",

+16

-0

foo.csv less more

	0	,A,B,C,D
	1	2020-01-01,-0.16657129011344146,0.39266281278146287,-0.48858338454915323,0.49416444739209253
	2	2020-01-02,-0.06283056709137139,-0.6066221559478102,-1.6058588216627525,0.5548133104360308
	3	2020-01-03,1.7411717294005558,-0.16969549688935975,-0.2755498331704511,-0.42871971142502313
	4	2020-01-04,1.351139739199027,1.1758582446600616,-0.6446400459877857,-1.9885048285011953
	5	2020-01-05,0.5742659583979928,0.5444137751931567,-1.1497060805403403,0.013115649607765364
	6	2020-01-06,1.675629137517467,-0.9878512204715905,-0.0960352451669729,0.7488544619242613
	7	2020-01-07,1.1492857670835492,-1.1288317295278794,-1.434470830803003,-0.8110520262538768
	8	2020-01-08,1.1227997937980252,0.7839392813941649,-0.6404779146634929,0.1051873090315463
	9	2020-01-09,1.0998378840088707,0.6152829543180992,-0.8760666419783472,0.8814417283691435
	10	2020-01-10,1.6657831422195308,1.2695956095701313,0.17809615360281755,-0.25716770691564916
	11	2020-01-11,0.7397085181697748,-0.610393045952476,-1.587274760355745,-0.6044560314610813
	12	2020-01-12,1.1292958939058046,-0.7718843047493298,-0.3917294755738199,0.13696843104391976
	13	2020-01-13,-0.4157101010479724,-0.1013465254142674,-1.0514731794267629,-0.4651289807790342
	14	2020-01-14,-0.8135028868460621,1.2502062558375586,-1.8983295385211765,0.49638457000287317
	15	2020-01-15,-1.319161502054464,-0.02301608352890381,1.8448874138304636,-0.8820651993261757