From 3a621e22738d2df0ed768015b2dcb90142aa7c68 Mon Sep 17 00:00:00 2001 From: 824zzy <614594368@qq.com> Date: Thu, 21 Jun 2018 10:11:23 +0800 Subject: [PATCH 1/2] fix($*.ipynb, $RNN/*.npy): Change some codes need to be modified result of Tensorflow's version --- .DS_Store | Bin 0 -> 6148 bytes .ipynb_checkpoints/LV3-checkpoint.ipynb | 467 +++++++++++ .ipynb_checkpoints/LV3_0.12-checkpoint.ipynb | 526 +++++++++++++ .ipynb_checkpoints/XOR_gate-checkpoint.ipynb | 647 ++++++++++++++++ .ipynb_checkpoints/core_code-checkpoint.ipynb | 159 ++++ FNN.py | 24 +- LV3.ipynb | 64 +- LV3_0.12.ipynb | 68 +- RNN/.DS_Store | Bin 0 -> 6148 bytes .../BGRU_BLSTM_scan_LV2-checkpoint.ipynb | 724 ++++++++++++++++++ .../LSTM_scan_LV1-checkpoint.ipynb | 365 +++++++++ RNN/BGRU_BLSTM_scan_LV2.ipynb | 42 +- RNN/LSTM_scan_LV1.ipynb | 31 +- RNN/X.npy | Bin 0 -> 6161390 bytes RNN/Y.npy | Bin 0 -> 3793010 bytes XOR_gate.ipynb | 185 ++--- core_code.ipynb | 77 +- 17 files changed, 3114 insertions(+), 265 deletions(-) create mode 100644 .DS_Store create mode 100644 .ipynb_checkpoints/LV3-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/LV3_0.12-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/XOR_gate-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/core_code-checkpoint.ipynb create mode 100644 RNN/.DS_Store create mode 100644 RNN/.ipynb_checkpoints/BGRU_BLSTM_scan_LV2-checkpoint.ipynb create mode 100644 RNN/.ipynb_checkpoints/LSTM_scan_LV1-checkpoint.ipynb create mode 100644 RNN/X.npy create mode 100644 RNN/Y.npy diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 %sD' %(layer_nodes[l],layer_nodes[l+1]))\n", + " # 存储所有隐藏层的输出\n", + " self.hid_layers.append(incoming)\n", + " # 加入dropout层\n", + " incoming = self.drop_layer(incoming)\n", + " \n", + " # 输出层的建立。输出层需要特别对待的原因是输出层的activation function要根据任务来变。\n", + " # 回归任务的话,下面用的是tf.identity,也就是没有activation function\n", + " if self.Task_type=='regression':\n", + " out_act=tf.identity\n", + " else:\n", + " # 分类任务使用softmax来拟合概率\n", + " out_act=tf.nn.softmax\n", + " self.output,l2_loss= self.layer(incoming,layer_nodes[-1],self.D_label, layer_name='output',act=out_act)\n", + " self.total_l2.append(l2_loss)\n", + " print('Add output layer: linear')\n", + " print(' %sD --> %sD' %(layer_nodes[-1],self.D_label))\n", + " \n", + " # l2 loss的缩放图\n", + " with tf.name_scope('total_l2'):\n", + " for l2 in self.total_l2:\n", + " self.l2_penalty+=l2\n", + " tf.summary.scalar('l2_penalty', self.l2_penalty)\n", + " \n", + " # 不同任务的loss\n", + " # 若为回归,则loss是用于判断所有预测值和实际值差别的函数。\n", + " if self.Task_type=='regression':\n", + " with tf.name_scope('SSE'):\n", + " self.loss=tf.reduce_mean((self.output-self.labels)**2)\n", + " self.loss2=tf.nn.l2_loss(self.output-self.labels)\n", + " \n", + " tf.summary.scalar('loss', self.loss)\n", + " else:\n", + " # 若为分类,cross entropy的loss function\n", + " entropy = tf.nn.softmax_cross_entropy_with_logits(self.output, self.labels)\n", + " with tf.name_scope('cross entropy'):\n", + " self.loss = tf.reduce_mean(entropy)\n", + " tf.summary.scalar('loss', self.loss)\n", + " with tf.name_scope('accuracy'):\n", + " correct_prediction = tf.equal(tf.argmax(self.output, 1), tf.argmax(self.labels, 1))\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n", + " tf.summary.scalar('accuracy', self.accuracy)\n", + " \n", + " # 整合所有loss,形成最终loss\n", + " with tf.name_scope('total_loss'):\n", + " self.total_loss=self.loss + self.l2_penalty*self.L2_lambda\n", + " tf.summary.scalar('total_loss', self.total_loss)\n", + " \n", + " # 训练操作\n", + " with tf.name_scope('train'):\n", + " self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.total_loss)\n", + "\n", + " # 洗牌功能\n", + " def shufflelists(self,lists):\n", + " ri=np.random.permutation(len(lists[1]))\n", + " out=[]\n", + " for l in lists:\n", + " out.append(l[ri])\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def Standardize(seq):\n", + " #subtract mean\n", + " centerized=seq-np.mean(seq, axis = 0)\n", + " #divide standard deviation\n", + " normalized=centerized/np.std(centerized, axis = 0)\n", + " return normalized\n", + "def Makewindows(indata,window_size=41):\n", + " outdata=[]\n", + " mid=int(window_size/2)\n", + " indata=np.vstack((np.zeros((mid,indata.shape[1])),indata,np.zeros((mid,indata.shape[1]))))\n", + " for i in range(indata.shape[0]-window_size+1):\n", + " outdata.append(np.hstack(indata[i:i+window_size]))\n", + " return np.array(outdata)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "mfc=np.load('X.npy')\n", + "art=np.load('Y.npy')\n", + "x=[]\n", + "y=[]\n", + "for i in range(len(mfc)):\n", + " x.append(Makewindows(Standardize(mfc[i])))\n", + " y.append(Standardize(art[i]))\n", + "vali_size=20\n", + "totalsamples=len(np.vstack(x))\n", + "X_train=np.vstack(x)[int(totalsamples/vali_size):].astype(\"float32\")\n", + "Y_train=np.vstack(y)[int(totalsamples/vali_size):].astype(\"float32\")\n", + "\n", + "X_test=np.vstack(x)[:int(totalsamples/vali_size)].astype(\"float32\")\n", + "Y_test=np.vstack(y)[:int(totalsamples/vali_size)].astype(\"float32\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "((37500, 1599), (37500, 24), (1973, 1599), (1973, 24))\n" + ] + } + ], + "source": [ + "print(X_train.shape,Y_train.shape,X_test.shape,Y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add dense layer: relu\n", + " 1599D --> 2048D\n", + "Add dense layer: relu\n", + " 2048D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 512D\n", + "Add dense layer: relu\n", + " 512D --> 256D\n", + "Add dense layer: relu\n", + " 256D --> 128D\n", + "Add output layer: linear\n", + " 128D --> 24D\n" + ] + } + ], + "source": [ + "# 生成网络实例\n", + "ff=FNN(learning_rate=7e-5, Layers=5, N_hidden=[2048,1024,512,256,128], D_input=1599, D_label=24, L2_lambda=1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "merged = tf.summary.merge_all()\n", + "train_writer = tf.summary.FileWriter('log3' + '/train',sess.graph)\n", + "test_writer = tf.summary.FileWriter('log3' + '/test')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def plots(T,P,i, n=21,length=400):\n", + " m=0\n", + " plt.figure(figsize=(20,16))\n", + " plt.subplot(411)\n", + " plt.plot(T[m:m+length,7],'--')\n", + " plt.plot(P[m:m+length,7])\n", + "\n", + " plt.subplot(412)\n", + " plt.plot(T[m:m+length,8],'--')\n", + " plt.plot(P[m:m+length,8])\n", + " \n", + " plt.subplot(413)\n", + " plt.plot(T[m:m+length,15],'--')\n", + " plt.plot(P[m:m+length,15])\n", + " \n", + " plt.subplot(414)\n", + " plt.plot(T[m:m+length,16],'--')\n", + " plt.plot(P[m:m+length,16])\n", + " plt.legend(['True','Predicted'])\n", + " plt.savefig('epoch'+str(i)+'.png')\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch0 | train_loss:0.693693 |test_loss:0.695782\n", + "epoch1 | train_loss:0.561398 |test_loss:0.583177\n", + "epoch2 | train_loss:0.478702 |test_loss:0.54134\n", + "epoch3 | train_loss:0.389257 |test_loss:0.482584\n", + "epoch4 | train_loss:0.320454 |test_loss:0.453059\n", + "epoch5 | train_loss:0.27317 |test_loss:0.441251\n", + "epoch6 | train_loss:0.234799 |test_loss:0.436898\n", + "epoch7 | train_loss:0.203948 |test_loss:0.436239\n", + "epoch8 | train_loss:0.176413 |test_loss:0.426064\n", + "epoch9 | train_loss:0.156074 |test_loss:0.425965\n", + "epoch10 | train_loss:0.132211 |test_loss:0.414978\n", + "epoch11 | train_loss:0.120031 |test_loss:0.40392\n", + "epoch12 | train_loss:0.105933 |test_loss:0.407968\n", + "epoch13 | train_loss:0.100558 |test_loss:0.402615\n", + "epoch14 | train_loss:0.0894171 |test_loss:0.39814\n", + "epoch15 | train_loss:0.0805371 |test_loss:0.395325\n", + "epoch16 | train_loss:0.0755967 |test_loss:0.396785\n", + "epoch17 | train_loss:0.0714638 |test_loss:0.399197\n", + "epoch18 | train_loss:0.0633848 |test_loss:0.399693\n", + "epoch19 | train_loss:0.0614749 |test_loss:0.393158\n", + "epoch20 | train_loss:0.0591606 |test_loss:0.394801\n", + "epoch21 | train_loss:0.055984 |test_loss:0.38638\n", + "epoch22 | train_loss:0.0540141 |test_loss:0.390381\n", + "epoch23 | train_loss:0.0496812 |test_loss:0.384337\n", + "epoch24 | train_loss:0.049253 |test_loss:0.387584\n", + "epoch25 | train_loss:0.0445422 |test_loss:0.383592\n", + "epoch26 | train_loss:0.0432337 |test_loss:0.382902\n", + "epoch27 | train_loss:0.0451354 |test_loss:0.382096\n", + "epoch28 | train_loss:0.041636 |test_loss:0.385363\n", + "epoch29 | train_loss:0.0392896 |test_loss:0.380636\n", + "epoch30 | train_loss:0.0386417 |test_loss:0.386117\n", + "epoch31 | train_loss:0.0378463 |test_loss:0.38561\n", + "epoch32 | train_loss:0.036046 |test_loss:0.383354\n", + "epoch33 | train_loss:0.0359106 |test_loss:0.381586\n", + "epoch34 | train_loss:0.0344725 |test_loss:0.379078\n", + "epoch35 | train_loss:0.0337404 |test_loss:0.376501\n", + "epoch36 | train_loss:0.0340016 |test_loss:0.379459\n", + "epoch37 | train_loss:0.032026 |test_loss:0.37459\n", + "epoch38 | train_loss:0.0317964 |test_loss:0.37812\n", + "epoch39 | train_loss:0.033109 |test_loss:0.37789\n", + "epoch40 | train_loss:0.0311886 |test_loss:0.372208\n", + "epoch41 | train_loss:0.0303357 |test_loss:0.370058\n", + "epoch42 | train_loss:0.0300332 |test_loss:0.37759\n", + "epoch43 | train_loss:0.0293583 |test_loss:0.36993\n", + "epoch44 | train_loss:0.0287083 |test_loss:0.373513\n", + "epoch45 | train_loss:0.0296841 |test_loss:0.371504\n", + "epoch46 | train_loss:0.0279586 |test_loss:0.370936\n", + "epoch47 | train_loss:0.0285195 |test_loss:0.373591\n", + "epoch48 | train_loss:0.0281992 |test_loss:0.37003\n", + "epoch49 | train_loss:0.0267218 |test_loss:0.368262\n" + ] + } + ], + "source": [ + "# 训练并记录\n", + "k=0\n", + "Batch=32\n", + "for i in range(50):\n", + " idx=0\n", + " X0,Y0=ff.shufflelists([X_train,Y_train])\n", + " while idxlen(layer_nodes):\n", + " nodes_in=layer_nodes[-1]\n", + " nodes_out=layer_nodes[-1]\n", + " else:\n", + " nodes_in=layer_nodes[l]\n", + " nodes_out=layer_nodes[l+1]\n", + " incoming,l2_loss= self.layer(incoming,nodes_in,nodes_out,prefix+'_hid_'+str(l+1),act=tf.nn.relu)\n", + " # 累计l2\n", + " self.total_l2.append(l2_loss)\n", + " # 输出一些信息,让我们知道网络在建造中做了什么\n", + " print('Add dense layer: relu')\n", + " print(' %sD --> %sD' %(nodes_in,nodes_out))\n", + " # 存储所有隐藏层的输出\n", + " self.hid_layers.append(incoming)\n", + " # 加入dropout层\n", + " incoming = self.drop_layer(incoming)\n", + " \n", + " # 输出层的建立。输出层需要特别对待的原因是输出层的activation function要根据任务来变。\n", + " # 回归任务的话,下面用的是tf.identity,也就是没有activation function\n", + " if self.Task_type=='regression':\n", + " out_act=tf.identity\n", + " else:\n", + " # 分类任务使用softmax来拟合概率\n", + " out_act=tf.nn.softmax\n", + " self.output,l2_loss= self.layer(incoming,layer_nodes[-1],self.D_label, layer_name='output',act=out_act)\n", + " self.total_l2.append(l2_loss)\n", + " print('Add output layer: linear')\n", + " print(' %sD --> %sD' %(layer_nodes[-1],self.D_label))\n", + " \n", + " # l2 loss的缩放图\n", + " with tf.name_scope('total_l2'):\n", + " for l2 in self.total_l2:\n", + " self.l2_penalty+=l2\n", + " tf.summary.histogram('l2_penalty', self.l2_penalty)\n", + " \n", + " # 不同任务的loss\n", + " # 若为回归,则loss是用于判断所有预测值和实际值差别的函数。\n", + " if self.Task_type=='regression':\n", + " with tf.name_scope('SSE'):\n", + " self.loss=tf.reduce_mean((self.output-self.labels)**2)\n", + " self.loss2=tf.nn.l2_loss(self.output-self.labels)\n", + " \n", + " tf.summary.histogram('loss', self.loss)\n", + " else:\n", + " # 若为分类,cross entropy的loss function\n", + " entropy = tf.nn.softmax_cross_entropy_with_logits(self.output, self.labels)\n", + " with tf.name_scope('cross entropy'):\n", + " self.loss = tf.reduce_mean(entropy)\n", + " tf.summary.histogram('loss', self.loss)\n", + " with tf.name_scope('accuracy'):\n", + " correct_prediction = tf.equal(tf.argmax(self.output, 1), tf.argmax(self.labels, 1))\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n", + " tf.summary.histogram('accuracy', self.accuracy)\n", + " \n", + " # 整合所有loss,形成最终loss\n", + " with tf.name_scope('total_loss'):\n", + " self.total_loss=self.loss + self.l2_penalty*self.L2_lambda\n", + " tf.summary.histogram('total_loss', self.total_loss)\n", + " \n", + " # 训练操作\n", + " with tf.name_scope('train'):\n", + " self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.total_loss)\n", + "\n", + " # 洗牌功能\n", + " def shufflelists(self,lists):\n", + " ri=np.random.permutation(len(lists[1]))\n", + " out=[]\n", + " for l in lists:\n", + " out.append(l[ri])\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def Standardize(seq):\n", + " #subtract mean\n", + " centerized=seq-np.mean(seq, axis = 0)\n", + " #divide standard deviation\n", + " normalized=centerized/np.std(centerized, axis = 0)\n", + " return normalized\n", + "def Makewindows(indata,window_size=41):\n", + " outdata=[]\n", + " mid=int(window_size/2)\n", + " indata=np.vstack((np.zeros((mid,indata.shape[1])),indata,np.zeros((mid,indata.shape[1]))))\n", + " for i in range(indata.shape[0]-window_size+1):\n", + " outdata.append(np.hstack(indata[i:i+window_size]))\n", + " return np.array(outdata)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mfc=np.load('X.npy')\n", + "art=np.load('Y.npy')\n", + "x=[]\n", + "y=[]\n", + "for i in range(len(mfc)):\n", + " x.append(Makewindows(Standardize(mfc[i])))\n", + " y.append(Standardize(art[i]))\n", + "vali_size=20\n", + "totalsamples=len(np.vstack(x))\n", + "X_train=np.vstack(x)[int(totalsamples/vali_size):].astype(\"float32\")\n", + "Y_train=np.vstack(y)[int(totalsamples/vali_size):].astype(\"float32\")\n", + "\n", + "X_test=np.vstack(x)[:int(totalsamples/vali_size)].astype(\"float32\")\n", + "Y_test=np.vstack(y)[:int(totalsamples/vali_size)].astype(\"float32\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "((37500, 1599), (37500, 24), (1973, 1599), (1973, 24))\n" + ] + } + ], + "source": [ + "print(X_train.shape,Y_train.shape,X_test.shape,Y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add dense layer: relu\n", + " 1599D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add dense layer: relu\n", + " 1024D --> 1024D\n", + "Add output layer: linear\n", + " 1024D --> 24D\n" + ] + } + ], + "source": [ + "# 生成网络实例\n", + "# 如果不指定全部隐藏层节点,则多出的隐藏层全部按最后一个指定的隐藏层节点数设定\n", + "ff=FNN(learning_rate=7e-5, Layers=50,N_hidden=[1024], D_input=1599, D_label=24, L2_lambda=1e-4)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "merged = tf.summary.merge_all()\n", + "train_writer = tf.summary.FileWriter('log' + '/train',sess.graph)\n", + "test_writer = tf.summary.FileWriter('log' + '/test')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def plots(T,P,i, n=21,length=400):\n", + " m=0\n", + " plt.figure(figsize=(20,16))\n", + " plt.subplot(411)\n", + " plt.plot(T[m:m+length,7],'--')\n", + " plt.plot(P[m:m+length,7])\n", + "\n", + " plt.subplot(412)\n", + " plt.plot(T[m:m+length,8],'--')\n", + " plt.plot(P[m:m+length,8])\n", + " \n", + " plt.subplot(413)\n", + " plt.plot(T[m:m+length,15],'--')\n", + " plt.plot(P[m:m+length,15])\n", + " \n", + " plt.subplot(414)\n", + " plt.plot(T[m:m+length,16],'--')\n", + " plt.plot(P[m:m+length,16])\n", + " plt.legend(['True','Predicted'])\n", + " plt.savefig('epoch'+str(i)+'.png')\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch0 | train_loss:[0.60085243] |test_loss:0.659336\n", + "epoch1 | train_loss:[0.56255817] |test_loss:0.653993\n", + "epoch2 | train_loss:[0.53966987] |test_loss:0.644001\n", + "epoch3 | train_loss:[0.47888839] |test_loss:0.609307\n", + "epoch4 | train_loss:[0.4274255] |test_loss:0.580894\n", + "epoch5 | train_loss:[0.41663638] |test_loss:0.58645\n", + "epoch6 | train_loss:[0.39932683] |test_loss:0.594072\n", + "epoch7 | train_loss:[0.35524291] |test_loss:0.57222\n", + "epoch8 | train_loss:[0.35336751] |test_loss:0.565518\n", + "epoch9 | train_loss:[0.30439419] |test_loss:0.545433\n" + ] + } + ], + "source": [ + "# 训练并记录\n", + "k=0\n", + "EPOCH=10\n", + "Batch=256\n", + "for i in range(EPOCH):\n", + " idx=0\n", + " X0,Y0=ff.shufflelists([X_train,Y_train])\n", + " while idx %sD' %(layer_nodes[l],layer_nodes[l+1]))\n", + " # 存储所有隐藏层的输出\n", + " self.hid_layers.append(incoming)\n", + " # 加入dropout层\n", + " incoming = self.drop_layer(incoming)\n", + " \n", + " # 输出层的建立。输出层需要特别对待的原因是输出层的activation function要根据任务来变。\n", + " # 回归任务的话,下面用的是tf.identity,也就是没有activation function\n", + " if self.Task_type=='regression':\n", + " out_act=tf.identity\n", + " else:\n", + " # 分类任务使用softmax来拟合概率\n", + " out_act=tf.nn.softmax\n", + " self.output,l2_loss= self.layer(incoming,layer_nodes[-1],self.D_label, layer_name='output',act=out_act)\n", + " print('Add output layer: linear')\n", + " print(' %sD --> %sD' %(layer_nodes[-1],self.D_label))\n", + " \n", + " # l2 loss的缩放图\n", + " with tf.name_scope('total_l2'):\n", + " for l2 in self.total_l2:\n", + " self.l2_penalty+=l2\n", + " tf.summary.scalar('l2_penalty', self.l2_penalty)\n", + " \n", + " # 不同任务的loss\n", + " # 若为回归,则loss是用于判断所有预测值和实际值差别的函数。\n", + " if self.Task_type=='regression':\n", + " with tf.name_scope('SSE'):\n", + " self.loss=tf.reduce_mean((self.output-self.labels)**2)\n", + " tf.summary.scalar('loss', self.loss)\n", + " else:\n", + " # 若为分类,cross entropy的loss function\n", + " entropy = tf.nn.softmax_cross_entropy_with_logits(logits=self.output, labels=self.labels)\n", + " with tf.name_scope('cross_entropy'):\n", + " self.loss = tf.reduce_mean(entropy)\n", + " tf.summary.scalar('loss', self.loss)\n", + " with tf.name_scope('accuracy'):\n", + " correct_prediction = tf.equal(tf.argmax(self.output, 1), tf.argmax(self.labels, 1))\n", + " self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n", + " tf.summary.scalar('accuracy', self.accuracy)\n", + " \n", + " # 整合所有loss,形成最终loss\n", + " with tf.name_scope('total_loss'):\n", + " self.total_loss=self.loss + self.l2_penalty*self.L2_lambda\n", + " tf.summary.scalar('total_loss', self.total_loss)\n", + " \n", + " # 训练操作\n", + " with tf.name_scope('train'):\n", + " self.train_step = tf.train.AdamOptimizer(self.learning_rate).minimize(self.total_loss)\n", + "\n", + " # 洗牌功能\n", + " def shufflelists(self,lists):\n", + " ri=np.random.permutation(len(lists[1]))\n", + " out=[]\n", + " for l in lists:\n", + " out.append(l[ri])\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 准备训练数据\n", + "inputs=[[0,0],[0,1],[1,0],[1,1]]\n", + "outputs=[0,1,1,0]\n", + "X=np.array(inputs).reshape((4,1,2)).astype('int16')\n", + "Y=np.array(outputs).reshape((4,1,1)).astype('int16')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add dense layer: relu with drop_keep:1.0\n", + " 2D --> 2D\n", + "Add output layer: linear\n", + " 2D --> 1D\n" + ] + } + ], + "source": [ + "# 生成网络实例\n", + "ff=FNN(learning_rate=1e-3, drop_keep=1.0, Layers=1, N_hidden=[2], D_input=2, D_label=1, Task_type='regression', L2_lambda=1e-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# 加载\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())\n", + "merged = tf.summary.merge_all()\n", + "train_writer = tf.summary.FileWriter('log' + '/train',sess.graph)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W_0:\n", + "[[ 0.50515938 1.1875577 ]\n", + " [-0.36632717 -0.7873252 ]]\n", + "W_1:\n", + "[[ 0.3926791 ]\n", + " [ 1.36484265]]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(4,2.5,u'1.36')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzt3Xl81NW9//HXycJmSNiCLAEjomEzBAiLgsCFVhA1ovUK9lYFLItirUWp26/22mtdbikqYllERdSC9rJFBRWKLIrsBkHZBUwgkoBAQggJSc7vjzMTskzIhHxnvjPf+TwfjzxMmO9kPjMmn5w533PeX6W1RgghhLOE2V2AEEII60lzF0IIB5LmLoQQDiTNXQghHEiauxBCOJA0dyGEcCBp7kII4UDS3IUQwoGkuQshhANF2PXAzZo10/Hx8XY9vBBCBKWtW7ce11rHVnecbc09Pj6eLVu22PXwQggRlJRSh705TqZlhBDCgaS5CyGEA0lzF0IIB5LmLoQQDiTNXQghHEiauxBCOJA0dyGEcKDga+6FhbB7N2zdaj5274aCArurCjpaax5++GHat29PYmIi27Ztq3RMbm4uSUlJpR/NmjXjkUceAeDw4cMMHjyYxMREBg4cSEZGhr+fguVOnD3B9p+2syljE2k/pZGRk4FchlIEK9s2MdVYbi5s2ADr15sG76Y11KkDfftC794QHW1fjUFk+fLl7Nu3j3379rFx40YeeOABNm7cWO6Yhg0bkpaWVvp1jx49uOOOOwB47LHHuPfee7nvvvtYtWoVTz75JO+++65fn4NVDp48yJrDa9h3Yh8ASim01mg0rRq2YsAVA+jcvDNhKvjGQiJ0KbtGJsnJydrrHarZ2fD225CTAy1amGZeVmEhHDsGUVEwejQ0b259wQ4zfvx4Bg4cyN133w1AQkICq1evpmXLlh6P37dvH4MGDeLHH39EKUXnzp357LPPiIuLQ2tNTEwMOTk5/nwKllj/43pS96YSXTeaJvWbVGrgOQU5ZOdl0zuuN7cl3EZ4WLhNlQphKKW2aq2Tqzsu8IciOTmmsRcVQdu2lRs7mH9r0wZKSuCtt8x9xEUdOXKENm3alH4dFxfHkSNHqjx+/vz5jBgxAqUUAF27dmXhwoUALF68mNzcXE6cOOHboi227eg2Uvem0ia6Dc0aNPM4Mo+uG82Vja9k05FNLN+33IYqhbg01TZ3pVQ9pdQmpdR2pdR3SqlnPRxTVyn1gVJqv1Jqo1Iq3rIK1683UzLNmlV/bNOmcPYsfPmlZQ/vVJ7esbkbtycLFiwoHeUDTJkyhTVr1tCtWzfWrFlD69atiYgInlm+gqICUvem0qphKyLDIy96bJgKI75RPOsz1nPszDE/VShE7Xgzci8ABmmtuwJJwFClVJ8Kx9wPnNRatwdeBl6ypLpz58w8e4sW3t/n8sth40ZzX1HO66+/XnpytFWrVqSnp5felpGRQatWrTzeb/v27RQVFdGjR4/Sf2vVqhWLFi3im2++4a9//SsAMTExvn0CFtp1fBfni89TL6KeV8eHqTAiwyLZclTC7kRwqLa5a+OM68tI10fFYd9twDuuz/8PGKwuNgz01g8/mPn0yIuPrMqJjDRTOPv31/rhnWbixImkpaWRlpbG8OHDmTdvHlprNmzYQExMTJXz7fPnzy83agc4fvw4JSUlALzwwguMGTPG5/Vb6euMr2lUr1GN7tP8suZsPrqZ88XnfVSVENbxas5dKRWulEoDsoAVWuuNFQ5pDaQDaK2LgNNA01pXd/o0hHs+gVVYFEbB+SrKDwuDU6dq/fBONmzYMNq1a0f79u0ZO3Ys//jHP0pvS0pKKnfshx9+WKm5r169moSEBK655hqOHTvG008/7Ze6rXIi7wQNIhtU+veC/HCe+dVdfLuuTaXbIsMjKSopIr8o3x8lClErNVoto5RqBCwGfqe13lnm378DhmitM1xfHwB6aa1PVLj/OGAcQNu2bXscPlxNLPH69bB8uTlZWkFeQQRZRXOIb5ZJpbcIhYUQE2NWzwjhwZHco0SERVQ6z7Br95X8buYr7MzoQr/he7j9oU1cFnNhH0X66XQeu/4xYuoFzxSUcBZvV8vU6AyY1vqUUmo1MBTYWeamDKANkKGUigBigJ893H82MBvMUshqHzA62qyA8eCyukWEnXmI+Wsu59e9DpS/8dAhGDkSEhOrf1IiJC3eOJ1zxeeIrnthX8TXH1/N+y/cwKMzP6Lr/lMseq0X33wRz69+v5HrbtlLiS5GKUX9yPo2Vi6Ed7xZLRPrGrGjlKoP/ALYXeGwVOA+1+d3Aqu0FQvo27WDiAgzh+7BFU3PEN/0DKv3lJkrLi42UzlXXVXrhxfOdV2b6ziZf7L064M7Y3nv+Rv4zdNrufLabG64fTd/WfghiTf8yDvPDmTK2FvZsVPTvWV36oR7WI4rRIDxZs69JfCFUupbYDNmzv1jpdRflFIprmPeBJoqpfYDk4AnLKmuQQPo0cNsUKrC9VcdI/tMPfYdc43AfvrJ3OeyyywpQThTx9iORIRFcL74PKeyGzDjsRsZNOI7+gy7cCK+YeNz3PfnNUyes5SzuXWY+dvxfPqPwZw5c5FvLESACPwdqidPwvTpUK+emUevwvQvOnNPxy3EqByYOBGaNLGwWuFEX/34FQt3LGPRHx+mYaMCJr78GWHhlX8ftNb8cCKdzJX/yaIZiTRurHj1Vbj9drBgTZgQNeKcHaqNG8P995t160ePmmmXioqLGd/+38z5qiPF946Wxi68cl3c9Xz7xkRycxV3/XmJx8Z+9vxZDp46yLUtOzDnxY7s2qXo3Rt+9Su45RazWleIQBT4I3e3n3+GNWtg2zbT4CMjzbDp/Hnz327dOH7tf7BodRPGjfNd3cI5pkyB556D95fv42D4Z2TmZqKUIiIsghJdQlFJETH1Yuh/RX96tepVLldm+XJ46CEz3nj6aZg8GerWtfHJiJDh7cg9eJq725kzsG+fafZgRvbXXFO67HHHDrNY5tZbratVOM/y5XDbbfDRRzBkiJl6OZJ7hMOnD3O28Cz1IurRsmFLrmx0ZZVhYfn58OKL5iM+Hl5/HX7xC/8+DxF6nNvcvfDppyYYsnt3n3x7EeT27DHp0H/6Ezz6aO2/39695jTPypVmBe7UqVDFZl8has05c+6XYOhQSEszC2eEKOvUKUhJMaP2SZOs+Z7XXAOffw4LFpiZw4QEmDatyhW8QviFI5s7wKhRMH++XKRJXFBcDHffbWbyZs2ydqWLUjBihLkw2Jgx8Ic/QK9eJsNOCDs4trmHhcHYsTBzprlYkxBPPAHffguLFpmVtb4QHQ2vvGKuAFm3Llx3HYwff+EUkRD+4tjmDuYc6223mRG8CG3z5pntEkuWQBXJxpZKSoKvvjLvEP71L+jQAd55RwYawn8c3dzBrGK44gpYvdruSoRdNm6EcePgjTegZ0//Pa773eOePWZN/KhRMGAA7NxZ7V2FqDXHN3cw187OyjIrKEVoOXrU7CR9+GH4zW/sqSE21lz9cd06s+G6Wzf44x+RGAPhUyHR3AHuugs++0wurxpK8vNh+HAzRfLCC3ZXA/36mT14L7wA//gHdOoEixfLVI3wjZBp7mBObM2Z4znBQDiL1mYqJicH/vnPKq/54neRkfDYY7Brl5kiuuMOiTEQvhFSzT0yEu69F9580+5KhK/9/e9m92lqKjSq2dX0/KJNG1i4ED75xCyf7NzZRCHI0l1hlZBq7gDNmpnlaR99ZHclwleWL4ennoIPPjAbjALZsGHmBOvkyfA//2OuL/Pvf9tdlXCCkGvuANdea0bx27bZXYmw2p49ZqPSCy+YzJhgUL8+/OUvJhepbVuTT/PrX0Nmpt2ViWAWks0dJKLAiXwRLeBPZWMMVq82a+Nfe01iDMSlCdnmDmbd8T//KfOcTuDLaAF/KhtjMHo0PPKIxBiISxPSzT0szKyokIiC4PfEE7B9u2+jBfzJU4zBhAkSYyC8F9LNHSSiwAn8HS3gT+4Yg5kz4cMPJcZAeC/kmztIREEw27TpQrRAr152V+Mb7neYe/bAzTdLjIHwjjR3F4koCD5Hj5odqHZGC/hTbCy8/TasXSsxBqJ60tzLkIiC4HHunMmMCZRoAX+64QaJMRDVk+Zewfjx5i2+RBQELne0wOnTgRUt4E+eYgxuvVViDMQF0twrkIiCwPf3v5tYgUCNFvCnsjEGu3ZJjIG4QJq7B7GxElEQqNzRAgsWBH60gD9JjIGoSJp7FSSiIPCUjRYYOtTuagKPxBiIsqS5X4REFAQOd7RASkpwRgv4k8QYCJDmXq1Ro8wGJ5nDtI87WqBRI5g9O3ijBfzJHWOwa5f5GXbHGGzaZHdlwl+kuVfDfR1MiSiwjztaYPFiZ0QL+FNMDLz6KmzZAnXqQJ8+Jsbg5Em7KxO+Js3dCxJRYJ9333VutIA/desG69dfiDFISJAYA6eT5u4liSjwv02bzLsmJ0cL+FNVMQbffWd3ZcIXpLnXgEQU+I87WuB3vwuNaAF/qhhjkJQkMQZOJM29hiSiwPfc0QJdu8KLL9pdjXNJjIGzSXO/BN5EFIwZM4bmzZvTpUsXj7fv3r2b6667jrp16zJlypRyt7366qt06dKFzp0788orr1hZesArGy0wf35oRgv4k1UxBtX9vC9dupTExESSkpJITk7myy+/LL3txx9/5MYbb6Rjx4506tSJQ4cO1eIZiVJaa1s+evTooYNZVpbWs2dXffuaNWv01q1bdefOnT3efuzYMb1p0yb91FNP6b/97W+l/75jxw7duXNnnZeXp8+fP68HDx6s9+7da3X5Aetvf9M6Jkbr3bvtriQ0ffKJ1ldeqXW9elo/95zW5855d7/qft5zc3N1SUmJ1lrr7du364SEhNLbBgwYoD///PPS4/Ly8mr3JBwO2KK96LEycr9EsbFmWVlVEQX9+/enSZMmVd6/efPm9OzZk8jIyHL/vmvXLvr06UODBg2IiIhgwIABLF682MrSA9ann16IFkhIsLua0DRsmDnBOnmy2e3atat3MQbV/bxHRUWhXBsU8vLySj///vvvKSoq4pe//GXpcQ0aNKj9ExHS3GvDFxEFXbp0Ye3atZw4cYKzZ8+ybNky0tPTrXuAALVnD4wcKdECgcAdY/DttxAXZ12MweLFi+nQoQM333wzb731FgB79+6lUaNG3HHHHXTr1o3JkydTLJGslqi2uSul2iilvlBK7VJKfaeU+r2HYwYqpU4rpdJcH8/4ptzAM3QofPONdREFHTt25PHHH+eXv/wlQ4cOpWvXrkRERFjzzQOURAsEpoQEWLHCnPv44osLMQaX2ntvv/12du/ezZIlS/jTn/4EQFFREevWrWPKlCls3ryZH374gblz51r3JEKYNyP3IuBRrXVHoA8wUSnVycNx67TWSa6Pv1haZYAbPdrkilsVUXD//fezbds21q5dS5MmTbj66qut+cYBSKIFAptS5h3V7t0XYgx69qxdjEH//v05cOAAx48fJy4ujm7dutGuXTsiIiIYPnw42yStzxLVNnetdabWepvr81xgF9Da14UFE/fmEKsiCrKysgCzimDRokXcfffdtf+mAUqiBYJDbWMM9u/fj3b9cmzbto3CwkKaNm1Kz549OXnyJNnZ2QCsWrWKTp08jR1FjXlz1tX9AcQDPwLRFf59IHAC2A4sBzpX972CfbWMJwcPav3+++bzkSNH6hYtWuiIiAjdunVrPWfOHD1jxgw9Y8YMrbXWmZmZunXr1rphw4Y6JiZGt27dWp8+fVprrXW/fv10x44ddWJiol65cqVNz8b35s3Tum5drTdutLsSURPFxVrPmqV148Zax8ZqPXdu9T/vL774ou7UqZPu2rWr7tOnj163bl3p9/v888/1tddeq7t06aLvu+8+XVBQYNdTCwp4uVpGaS+HmkqpKGAN8Fet9aIKt0UDJVrrM0qpYcCrWutKcwlKqXHAOIC2bdv2OHz48CX8OQpsX31lolUHDLC7ksC2aRP072/2C9xzj93ViEuRnW12ts6dazZEzZhhrgQlfEsptVVrnVzdcV6tllFKRQILgfcrNnYArXWO1vqM6/NlQKRSqpmH42ZrrZO11smxsbHePHTQ6dsXjh2D/fvtriRwlY0WkMYevMrGGPz8s4kxePxxyMuzuzIB3q2WUcCbwC6t9dQqjmnhOg6lVC/X9z1hZaHB5K67zJptiSioTKIFnOeGG8yKsRdegNdfh44dTYqnxBjYy5uRe1/gHmBQmaWOw5RSE5RSE1zH3AnsVEptB6YBI7W38z0ONW5c9REFoUaiBZyrYozB7bebGIODB+2uLHR5PeduteTkZL1lyxZbHttfsrPNKpBx4+yuJDD8/e/m4s0bN8oOVKdbtgweeshsfPp//880/rp17a7KGSydcxeXprqIglDy6afw5JMSLRAqLjXGQFhHmruPJSZaH1EQbNzRAs8/L9ECocRXMQbCO9Lc/WDoUEhLsy6iIJiUjRZ49FG7qxF2sDrGQHhHmrufjBplbURBMJBoAeHmKcagV6/axRiIi5Pm7idWRxQEA4kWEBW5Yww2b4aICHNO6oEHvI8xEN6T5u5HUVFw223m7anTvfuueeu9ZAm0amV3NSLQdO8OX39tBjsffGCmbubNC52Bjz9Ic/ez+Hi44gpYvdruSnxn0yYYO9as8+/Vy+5qRKByv5vdvRtuvhnuuw8GDjSrbETtSXO3Qd++kJXlzIgCiRYQNdW8+YUYgxMnJMbAKtLcbeLEiAKJFhC1ITEG1pLmbiMnRRS4owVOnZJoAXHpJMbAOtLcbVSnDtx7L7guJxnUpk6F1FTz0aiR3dWIYNemDSxcCJ98At9/b6KEn38+tJYS15Y0d5vFxkLv3sEdUeCOFpg/X6IFhLWGDYOdO80GuP/+bzPlt2qV3VUFB2nuASCYIwrKRgvcdJPd1QgnatDABM7t2GFiDAYPhv/6r9Dc8V0T0twDxNCh5mRSMP3Anjpl1u1LtIDwh7IxBqtWma+nT3fGOStfkOYeQEaPDp6IAne0QEyMRAsI/6kYY/D730uMQVWkuQeQYIooePJJiRYQ9pEYg+pJcw8wwRBR8O67MG2aaewSLSDsJDEGVZPmHoDcEQVr1thdSWVlowV697a7GiHKxxgMGyYxBm7S3ANU375w7FhgRRRItIAIZM2bw9y5ZlDkjjF44onQjTGQ5h7AAimiQKIFRLDo39+sPHv+eZNM2qlTaMYYSHMPcIEQUSDRAiLYREaa67fu2gU9epiBSUpKaMUYSHMPcIEQUSDRAiJYtW0LixbBxx+bOfhQijGQ5h4E7IwokGgB4QQ33xx6MQbS3INEYqJZz+vPiAKJFhBOEmoxBtLcg8hNN/kvosAdLXDrrRItIJwlVGIMpLkHGX9EFJSNFnjjDYkWEM5TNsbgvvsuxBhs3mx3ZdaR5h5k3Bs2Zs3y3dIuiRYQoSImxuy2dscY9O4NDz7ojBgDae5BKCrKTJf4IqJAogVEKOreHdavhxkzLiweCPYYA2nuQerKK80yLysjCiRaQISy8HAYP94sJHBCjIE09yDWr585uWpFRMHRo2ajx0MPSbSACG1OiTGQ5h7kRoyA5ctrF1HgjhZITISXXrKuNiGCmacYg6VL7a7Ke9LcHWD8eDOVUlJS8/tKtIAQVasYYzB8uIkxOHTI7sqqJ83dAdwRBW++WfP7SrSAENUrG2Owc6cZxT//PBQW2l1Z1aS5O4Q7ouDjj72/j0QLCFEz7hiDSZO8jzEoKYHDh+HbbyEtzaytz8/3fa0Rvn8I4S+JiXDkiJkn7Nbt4sdKtIAQl6ZBA3juObPw4MEHL8QYTJkCLVpcOO78edPM16ypvG4+PNwMxvr0gaZNfVOnjNwd5qabTP7MxSIKTp+WaAEhaishAVauNDvG//3v8jEG+flmnfzChWbj4RVXlP9o0cIsPX7tNd/N30tzd6CLRRS4owWio2H2bIkWEKI2lDK/T2VjDHr2hBdeMFMx7dqZTYcVRURA69bm9/CttyAz0/raqm3uSqk2SqkvlFK7lFLfKaV+7+EYpZSappTar5T6VinV3fpShbfcEQUzZ1beYffkk+at4uLFUL++PfUJ4TRlYwzOnzfpk2vXVr82PirKRHzU5FyZt7wZuRcBj2qtOwJ9gIlKqU4VjrkJuNr1MQ6YYWmVosaiosySrQULLvzbe+9diBZo3dq+2oRwqu7dzdLkO+4wjf7Pf4YNGy4eY9C0qblCVFaWtbVU29y11pla622uz3OBXUDF1nAbME8bG4BGSqmW1pYqasodUbB2rZnf++1vzVSMRAsI4RvHjpkpliFD4NlnoUsXePtts+T46FHP91HKrKffvt3aWmo0566Uige6ARsr3NQaSC/zdQaV/wAIG/Tta7IxUlJMtMC999pdkRDOlZt74TxWdDSMGmUWLeTmmqmaf/3Lc258/fqQnW1tLV43d6VUFLAQeERrXXGzu6fTcpXeiCilximltiiltmRb/UyER+fOmZyMJk3g6aftrkYI56u4SOGaa8w5sE6dICPDnBPzdJ9L2WF+MV41d6VUJKaxv6+1XuThkAygTZmv44BKb0K01rO11sla6+TY2NhLqVfUQNlogdWrzVl5q3+AhBAXNGhQ/nessNCsc8/KMu+cH3nE8wq1/Hxo3NjaWrxZLaOAN4FdWuupVRyWCtzrWjXTBzittfbB4h5RE1OnmqCj1FSTdHepEQVCCO+0aGHeJeflwfffw5dfmis8JSWZpl7V0uPCQrMJ0UrejNz7AvcAg5RSaa6PYUqpCUqpCa5jlgE/APuBN4AHrS1T1NRnn5lljwsWXIgWuJSIAiGE98LCzO/bRx+ZFWuDBlW/5Dgnxwy+4uKsraXa+AGt9Zd4nlMve4wGJlpVlKidvXtNFPBf/1o5WqAmEQVCCO+dP2+uZBYWBrfcAmfPVn+fggKTGX///dZvKJRsGYc5fdqsjLn1VnjsMc/H3HSTmZ5p2bJ8FoYQ4tJ89RVs3GjyZmJjTZbMW29Berr5PYuo0Gm1NsecPg133QXt21tfk9I2XSQwOTlZb9myxZbHdqriYtPUjx83J3Eu9nawpAReeQUmToS6df1XoxBOkp1tRuu9epkro5V15oxZyLB5MxQVmWhupcz8ekkJxMfDjTea/9aEUmqr1jq5uuNk5O4g7miBzZurn+dzRxTMmgW/+51kzAhREyUl5nxWQYH5/YmMrHxMVJSZnhk82GTPZGebJh8dbZZHNm/u2xqluTuEO1pgzRrvowWiosxIf8ECE34khKheWppJgxwxAtq0qf74+vXtOb8lqZAOUJtogSuvND+ga9b4pjYhnCInx0T0ZmWZ81neNHY7ycg9yGVmmotb1yZaoF8/+OAD2L/fNyd2hAhmWpv9Ij/9ZAZRwZKmKiP3IHbunGns114LL71Uu+81YgQsX25GJ0IIY+9e+NvfoGNHmDAheBo7SHMPWlqbaNGTJ82ceXh47b/n+PHwxhsSUSBEfj7MmGFC9yZPDs5rDMu0TJB6+WVYssTMtzdqZM33rFPnQkTB2LHWfE8hgs3nn1+4slJMjN3VXDoZuQehzz6DJ54oHy1gFYkoEKEqPd1MwcTGwsMPB3djBxm5B52LRQtYRSIKRChxxwbUq2ey1z1F8gYjae5BxJtoAau4IwpatYLLL/ftYwlhl4qxAU7ikL9RzldcbDYaRUeb9ez+2FE6ejS8/77ZhSeEk2Rnm/NWAJMmOa+xg4zcg0ZNogWsIhEFwmnKxgY89JDn2ACnkOYeBC4lWsAqElEgnCItDVasgJEjA393qRVkWibAbd5sliVeSrSAVdwRBWvX2vP4QtRGTo4ZHB07Ztash0JjBxm5B7TMTBg+3MTyXmq0gFXcEQUHDsBVV9lbixDeKBsbMHZscO0utYKM3AOUldECVpGIAhEsgjk2wCrS3AOQL6IFrDJunEQUiMCVnw8zZwZ3bIBVZFomAPkiWsAqElEgApVTYgOsIiP3AOOOFpg/P3BHHRJRIAJJejpMmeKc2ACryMg9gJSNFhg2zO5qLk4iCoTdysYGTJrknNgAq0hzDxD+jBawikQUCLu4YwN+8xvfX4s0WMnfugBgR7SAVSSiQPhTdjZMnWoWHUyaJI39YmTkHgCeesr/0QJWkYgC4Q/u2IBz58zPmZNjA6wizd1m770Hr75qT7SAVSSiQPhSWhqsXGnOR4XK7lIryLSMjQIhWsAqElEgrJaTA6+9ZmIDHntMGntNycjdJu5ogQcftD9awCoSUSCsUDY24Le/Db6pykAhI3cbBGK0gFXuuguWLZOIAnFpJDbAOtLc/Uxr80P7889mo1KEw947KWWiEySiQNSExAZYz2GtJfC9/DIsXmzW6DZubHc1viERBaImJDbAN2Tk7kdlowU6dLC7Gt+SiAJRnfR0MwXTrJnEBviCjNz9JJiiBawiEQXCk7KxAY8+KrEBviIvq49prRk//mG6dGmPUokMGrTN43FDhw6la9eudO7cmQkTJlBcXAzAiBEjSEpKIikpifj4eJKSkvxZfq3ddBNs22aWswln+/TTT0lISKB9+/a8+OKLlW6fOXMmV111LfHxScya1Y+kpO8JC4PCwkJGjx7NtddeS9euXVm9erX/i3cirbUtHz169NChIDX1E92s2VDdo0eJXr36a92rVy+Px50+fVprrXVJSYm+44479Pz58ysdM2nSJP3ss8/6tF5fKC7WesoUrc+ds7sS4StFRUW6Xbt2+sCBA7qgoEAnJibq7777rvT27Gyt//rX03rdOvP10qVL9ZAhQ7TWWk+fPl2PGjVKa631sWPHdPfu3XVxcbHfn0OwALZoL3qsjNx97E9/Wsr58/eydKliwIA+nDp1iszMzErHRUdHA1BUVERhYSGqwj5+rTUffvghdwfhFtCwMLOCZtYss1pIOM+mTZto37497dq1o06dOowcOZKlS5dSUmLOMaWmwuTJ0fTrZ47Py8sr/Rn//vvvGTx4MADNmzenUaNGbNmyxa6n4hjS3H3ovfdgx44jvPRSm9Jogbi4OI4cOeLx+CFDhtC8eXMaNmzq4iMLAAATjklEQVTInXfeWe62devWcfnll3P11Vf7umyfKBtRIJznyJEjtCmzhTQuLo7t248wdSr07Qtjxpg8mNdff52rrrqKP/7xj0ybNg2Arl27snTpUoqKijh48CBbt24lPT3drqfiGNU2d6XUW0qpLKXUzipuH6iUOq2USnN9PGN9mcHHHS3QpYumc+fyt1Uclbt99tlnZGZmUlBQwKpVq8rdNn/+/KActZclEQXOpcu8JcvJMcsb8/MVjz0GbdteOG7ixIkcOHCAl156ieeeew6AMWPGEBcXR3JyMo888gjXX389EU7bAGIDb0buc4Gh1RyzTmud5Pr4S+3LCm7PP/8611+fRMOGSfTq1arcKCQjI4NWrVpVed969eqRkpLC0qVLS/+tqKiIRYsWMWLECJ/W7Q/9+pnohQMH7K5EWCkuLo709HSWLDER0O3bZ9CnT9U/5yNHjmTJkiUARERE8PLLL5OWlsbSpUs5depU0L5DDSTVNnet9VrgZz/U4gjnzkFq6kQGD07j6NE0hg8fzrx589Bas2HDBmJiYmjZsmW5+5w5c6Z0Hr6oqIhly5bRocxC+JUrV9KhQwfi4uL8+lx8RSIKnCcmpidbtuyjYcOD3H9/IYsWLSAlJaXcMfv27Sv9/JNPPilt4GfPniUvLw+AFStWEBERQadOnfxXvENZ9d7nOqXUduAo8JjW+juLvm9QKRstsHy5iRYYNmwYy5Yto3379jRo0IC333679PikpCTS0tLIy8sjJSWFgoICiouLGTRoEBMmTCg9bsGCBUE/JVOWO6LgtdfgD3+Qdc7BLD8f3nkHLr88gnnzpvPAA0MoLi5mzJgxdO7cmWeeeYbk5GRSUlKYPn06K1euJDIyksaNG/POO+8AkJWVxZAhQwgLC6N169a8++67Nj8rZ1Dai+ULSql44GOtdRcPt0UDJVrrM0qpYcCrWmuP76mUUuOAcQBt27btcfjw4VqUHnimToVnnzXRAk7fgWqFrCyT/icRBcFpxQoTG3DvvbK71J+UUlu11snVHVfrMZPWOkdrfcb1+TIgUinVrIpjZ2utk7XWybGxsbV96IASStECVmneHHr1koiCYJORYWIDmjY1V0WSxh6Yaj0to5RqARzTWmulVC/MH4wTta4siLijBZ57LnSiBazStatEFAQLd2xA3brm+qXh4XZXJC6m2uaulJoPDASaKaUygD8DkQBa65nAncADSqkiIB8Yqb2Z63GI06chJQVuucVElYqaGzYM5syBVq3g8svtrkZ4sn49bNgAv/mNXJQ6WHg15+4LycnJOth3oRUXm8aelWXWbsuFBS5dSQm88gpMnGhGhiIwHD8O8+aZ6TP37lJhL2/n3GWnQC089ZQJxdqyRRp7bYWFwbhx5nqyDz1kVtQI+5SUmEsm5uebefXISLsrEjUlzf0Svf8+vPoqrF5NabSAqJ2oKDO9tWABOGjlZ9BJS4OVK81+hLK7S0VwkRXGl2DzZnPh3lmzoE8fu6txFokosE9ODkybZuKZK8YGiOAjI/caysyE4cPhwQfNZcGE9fr1M6P3Awfgqqvsrsb5tDb7DX76yQxaGjSwuyJhBRm518C5c3D77dClC7z0kt3VONuIERJR4A/79pk16x07mt3V0tidQ5q7l8pGCyxYYKIFhO+4IwreeMOc3BPWys+HmTNh506zhDchwe6KhNWkRXnp5Zdh8WITLdC4sd3VhIY6deCee+Ctt8x0gbDGihWwa5eZVpTdpc4lI3cvSLSAfZo3h5494ZNP7K4k+JWNDXj4YWnsTicj92rs3QsjR0q0gJ3cEQVpaRBk1wcPCBIbEJqkuV+EO1rg5pslWsBuw4bBm29Cy5YSUVATEhsQumRapgrFxfDrX0PDhuaknuyYtN/o0WbzWEGB3ZUEvuPHzXmikhIzWpfGHnpk5F4FiRYIPO6IglmzzJZ4+YNbWdnYgIcektiAUCbN3QOJFghcUVFw660SUeDJ9u1mJYzEBgiQaZlKJFog8ElEQXnu2IDMTIkNEBfIyL0MiRYIHhJRcCE2IDNTYgNEZTJyd5FogeDjjijIzbW7Ev8rGxvwwAPS2EVl0tyRaIFgFYoRBefOSWyA8I60McwVgCRaIDjVqWPWcIdCRIHEBoiaCPmR+2efweOPS7RAMHN6REFGBkyZIrEBomZCeuQu0QLO4cSIgvPn4b33zLuTP/xBYgNEzYRsc5doAecZNgzmzHFGRIHEBojaCslpGYkWcK4xY8xoN1gjCo4fh6lTzc+oxAaI2gjJkfvTT0u0gFOFhZkVNLNnm+33wfKHu2xswO9+J7EBovZCrrm//75ZHSPRAs4VFQW33GKa5ciRdldTPYkNEL4QUtMyEi0QOq68EuLiAjuiIDcXXntNYgOEb4TMyN0dLfDAAxItECoCNaJAa0hNhaNH4f77ZXep8I2QGLmXjRb43/+1uxrhT4EWUeCODejQQWIDhG85vrlLtEBoc0cUzJ5tb0SBOzZgxw6JDRD+4fhW544W2LBBogVCVZ06cM899kUUSGyAsIOjR+5lowU6drS7GmEnOyIKMjLMFIzEBgg7OHbkvm+fRAuI8vwVUVA2NmDSJIkNEPZwZHOXaAFRFV9HFEhsgAgUjpuWcUcLREVJtIDwbMwYs5mtsNC673n8OLz8ssQGiMARfM29uBgOHTJXK9i503xeXFx6sztaYPFiiRbw5NNPPyUhIYH27dvz4osvVrp97ty5xMbGkpSURFJSEnPmzCm9bejQoTRq1IhbbrnFnyVbLiwMxo41q1e0vvDvuQW57Dm+hx3HdrArexfHzx6v9nuVlJhzOqmpJu7ghht8WLgQNRA80zL5+fDNN7BunbkisHtIrrUZpvfvz/t7knnllbqsXm12J4ryiouLmThxIitWrCAuLo6ePXuSkpJCp06dyh03YsQIpk+fXun+kydP5uzZs8yaNctfJftMw4YmomDBAhhwy1HWp69n+0/b0VqjlSaMMIp1MVc3uZp+bftxddOrK32P7dvh889NbMAVV9jwJIS4iOBo7qdOwdy5kJ1t3u9WXNOYn8/mOdv57fu9mfVKHn36XGZLmYFu06ZNtG/fnnbt2gEwcuRIli5dWqm5V2Xw4MGsXr3ahxX6V7t28MW3e3l8zhqu7p5Jq4atCA+7cPZTa81PZ37izW/eZMAVAxjSfghhKozcXPPjePXVck5HBK7Ab+5nz5rfpDNnqhweZRY2YfiSO3ggeQv3nVsPeePhMmnwFR05coQ2bdqUfh0XF8fGjRsrHbdw4ULWrl3LNddcw8svv1zuPk7yXdZ37It6l/C8gYSfiiI8qvw2VqUUTRs0pVG9Rqw5tIaIsEjO7vyFxAaIoFDtnLtS6i2lVJZSamcVtyul1DSl1H6l1LdKqe6WVrh+vTlbVcUZqnPnw7ljxo10afUz/3vPDjhxwtxHVKLLTjC7qApnnG+99VYOHTrEt99+yy9+8Qvuc2gQT2FxIYt2LaJlVEuuG/ojO75sy7k8zzm74WHh1M9J5IWXimje9qTEBoig4M0J1bnA0IvcfhNwtetjHDCj9mW5FBaaRt2ihcebtYYH3u/Hiby6LPjtv4kI12aN2/r11i6FcIi4uDjS09NLv87IyKBVq1bljmnatCl169YFYOzYsWzdutWvNfrLvhP7OFd0jvqR9VEK+v9qF+sWd6gUUXC+IJw1/9eRzB+a0Xfkes5Eb7GnYCFqqNrmrrVeC/x8kUNuA+ZpYwPQSCnV0pLqfvjBXFKnTh2PN7/y72tZ+M2VLH3wcxpf5mrmdeqY++zfb0kJTtKzZ0/27dvHwYMHKSwsZMGCBaSkpJQ7JjMzs/Tz1NRUOjp0a+/69PVE140u/ToisoTew/axPvVC6Muuja1Zt7gDvYbup/ugQ1we1ZyvM76mqKTIjpKFqBEr5txbA+llvs5w/Vum58Nr4NSpKheqf/59ax5f1IvFD3xOx5anyt8YHg4nT9b64Z0mIiKC6dOnM2TIEIqLixkzZgydO3fmmWeeITk5mZSUFKZNm0ZqaioRERE0adKEuXPnlt7/hhtuYPfu3Zw5c4a4uDjefPNNhgwZYt8TqoVjecdoXK/8ifnoJue4olM2X3/cntyTDejQ8wiDRn5Xenud8DoUFhdy9vzZcn8YhAhEytM8bKWDlIoHPtZad/Fw2yfAC1rrL11f/xv4o9a60vt5pdQ4zNQNbdu27XH48OGLP/CXX5qAGA8n9Kat6kxBSTqTh71X+X45OWYphFz9QFRh7eG11I9sQJiq/OZ107ZEEnocYX/TvpVu+/H0j0y+fjIx9SQoRthDKbVVa51c3XFWjNwzgLLdNw446ulArfVsYDZAcnJy9X9VoqPLbVAq6+FBrhFVYUrlG386BP3vgkQfBoiIoPZN/qsUlxQTVSeq0m3hN8J+4iv9e3FJMQpFvYh6fqhQiNqxYodqKnCva9VMH+C01rr2UzJgRt9hYVU2eI+Ki819AunSOyLg9G7dmxP5J2p0n+Nnj5N4eSJ1I+r6qCohrOPNUsj5wNdAglIqQyl1v1JqglJqguuQZcAPwH7gDeBBy6qLioIePSAry/v7ZGeb+L+GDS0rQzhPl+ZdCCPM65OjWmvOnj9L77jePq5MCGtUOy2jtb67mts1MNGyiirq18/s8z5zxjT7izlzBoqKYMAAn5UjnCGqThQDrxzIigMriG8U73Huvaz0nHQ6xXaiTbQzN3QJ5wn84LDYWBg1yqycycryfK20khIzYj91CkaPlkg+4ZX/iP8Prou7joMnD3L2/FmPxxQWF3Lo5CHiG8Xzn53/s9KmLyECVeDHDwDEx8ODD5qUpj17zJy6a6MNBQWmuSckwI03VrnhSYiKwlQYKQkptGrYilWHVpGVl0Wd8DpEhkVSrIspKCqgbkRdBl81mBva3kCdcM/7LYQIRF4thfSF5ORkvWXLJez2+/ln+P5781+tzTXMOnY0/xXiEpXoEg6ePMj+n/eTdz6PeuH1aBPThoRmCdLURUDx51JI/2rSxMzDC2GhMBXGVU2u4qomsspKOEPgz7kLIYSoMWnuQgjhQNLchRDCgaS5CyGEA0lzF0IIB5LmLoQQDiTNXQghHEiauxBCOJBtO1SVUtlANVfrqFYz4LgF5VgtEOsKxJpA6qqJQKwJpK6asKKmK7TWsdUdZFtzt4JSaos323D9LRDrCsSaQOqqiUCsCaSumvBnTTItI4QQDiTNXQghHCjYm/tsuwuoQiDWFYg1gdRVE4FYE0hdNeG3moJ6zl0IIYRnwT5yF0II4UHAN3el1FtKqSyl1M4qbldKqWlKqf1KqW+VUt0DpK6BSqnTSqk018czfqipjVLqC6XULqXUd0qp33s4xu+vl5d1+fX1UkrVU0ptUkptd9X0rIdj6iqlPnC9VhuVUvG+rKkGdY1SSmWXea1+6+u6XI8brpT6Rin1sYfb/P5aeVmXXa/VIaXUDtdjVroqkV9+D7XWAf0B9Ae6AzuruH0YsBxQQB9gY4DUNRD42M+vVUugu+vzhsBeoJPdr5eXdfn19XI9/yjX55HARqBPhWMeBGa6Ph8JfBAgdY0CpvvzZ8v1uJOAf3r6/2THa+VlXXa9VoeAZhe53ee/hwE/ctdarwV+vsghtwHztLEBaKSUahkAdfmd1jpTa73N9XkusAtoXeEwv79eXtblV67nf8b1ZaTro+IJqNuAd1yf/x8wWPn4Ctle1uV3Sqk44GZgThWH+P218rKuQOXz38OAb+5eaA2kl/k6A5sbRxnXud5eL1dKdfbnA7veFnfDjPzKsvX1ukhd4OfXy/V2Pg3IAlZorat8rbTWRcBpwOcX6/WiLoBfud7O/59Sqo2vawJeAf4IlFRxuy2vlRd1gf9fKzB/kD9XSm1VSo3zcLvPfw+d0Nw9jQ5sH+kA2zDbhLsCrwFL/PXASqkoYCHwiNY6p+LNHu7il9ermrr8/npprYu11klAHNBLKdWlYsme7hYAdX0ExGutE4GVXBgx+4RS6hYgS2u99WKHefg3n75WXtbl19eqjL5a6+7ATcBEpVT/Crf7/PVyQnPPAMr+NY4DjtpUSymtdY777bXWehkQqZRq5uvHVUpFYhro+1rrRR4OseX1qq4uu14v1+OdAlYDQyvcVPpaKaUigBj8OBVXVV1a6xNa6wLXl28APXxcSl8gRSl1CFgADFJKvVfhGDteq2rrsuG1cj/uUdd/s4DFQK8Kh/j899AJzT0VuNd19rkPcFprnWl3UUqpFu45R6VUL8xrfcLHj6mAN4FdWuupVRzm99fLm7r8/XoppWKVUo1cn9cHfgHsrnBYKnCf6/M7gVXadTbMzroqzM2mYM5h+IzW+kmtdZzWOh5zsnSV1vo3FQ7z+2vlTV3+fq1cj3mZUqqh+3PgRqDiqjqf/x5GWPnNfEEpNR+zkqKZUioD+DPmJBNa65nAMsyZ5/3AWWB0gNR1J/CAUqoIyAdG+vqHHTOSuQfY4ZqzBXgKaFumLjteL2/q8vfr1RJ4RykVjvlD8qHW+mOl1F+ALVrrVMwfpHeVUvsxo9CRPqynJnU9rJRKAYpcdY3yQ12VBMBr5U1ddrxWlwOLXWOVCOCfWutPlVITwH+/h7JDVQghHMgJ0zJCCCEqkOYuhBAOJM1dCCEcSJq7EEI4kDR3IYRwIGnuQgjhQNLchRDCgaS5CyGEA/1/u45EoIw3EwkAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练前的权重\n", + "\n", + "\n", + "W0=sess.run(ff.W[0])\n", + "W1=sess.run(ff.W[1])\n", + "print('W_0:\\n%s' %sess.run(ff.W[0]))\n", + "print('W_1:\\n%s' %sess.run(ff.W[1]))\n", + "\n", + "plt.scatter([1,1,5],[1,3,2],color=['red','red','blue'],s=200,alpha=0.4,marker='o')\n", + "plt.scatter([3,3],[1,3],color=['green','green'],s=200,alpha=0.4,marker='o')\n", + "\n", + "plt.plot([1,3],[1,1],color='orange',linewidth=abs(W0[0,0]))\n", + "plt.annotate('%0.2f' %W0[0,0],xy=(2, 1.0))\n", + "\n", + "plt.plot([1,3],[3,1],color='blue',linewidth=abs(W0[1,0]))\n", + "plt.annotate('%0.2f' %W0[1,0],xy=(1.5, 1.5))\n", + "\n", + "plt.plot([1,3],[1,3],color='blue',linewidth=abs(W0[0,1]))\n", + "plt.annotate('%0.2f' %W0[0,1],xy=(1.5, 2.5))\n", + "\n", + "plt.plot([1,3],[3,3],color='orange',linewidth=abs(W0[1,1]))\n", + "plt.annotate('%0.2f' %W0[1,1],xy=(2, 3))\n", + "\n", + "plt.plot([3,5],[1,2],color='blue',linewidth=abs(W1[0]))\n", + "plt.annotate('%0.2f' %W1[0],xy=(4, 1.5))\n", + "\n", + "plt.plot([3,5],[3,2],color='blue',linewidth=abs(W1[1]))\n", + "plt.annotate('%0.2f' %W1[1],xy=(4, 2.5))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.27575219]\n", + " [ 0.1 ]\n", + " [ 2.0949471 ]\n", + " [ 0.87652308]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAFXNJREFUeJzt3XGwXnV95/H3h5BIBAcCuUoacgkUuhtoEfEO0mFHcWwhMCuprc6Q7So6ama6sm13d3bGdmdkFqcz3e2MnXHXFtM1g+5UoKvSTTtaoIKyuxXKDYsiIBpDgUuoiQQRFjVN8t0/nhP7cLk39+Te597n3pz3a+bMfc7v/M7zfH8c/dyT3z3POakqJEndcdywC5AkLSyDX5I6xuCXpI4x+CWpYwx+SeoYg1+SOsbgl6SOMfglqWMMfknqmOOHXcBUVq9eXevXrx92GZK0ZOzYseP7VTXSpu+iDP7169czPj4+7DIkaclI8kTbvk71SFLHGPyS1DEGvyR1jMEvSR1j8EtSxxj8ktQxi/JyTknzY/9+eOQR+Pu/h9FR+Lmfg+NNgc7xkEsdceAAfOYz8N3vwgknwFe+AhdcAJs3QzLs6rSQnOqROmLnzt5y1lmwZk3v50MPwVNPDbsyLTSDX+qIfftePq2TwHHHwQ9/OLyaNBwGv9QRZ5wBBw/2FoB/+Ifez9NPH15NGg7n+KWOWLcOLrsMvvrV3pl+FVx1FaxePezKtNAMfqkjErjiChgbg+ee6wX+KacMuyoNg8Evdcxpp/UWdZdz/JLUMTMGf5J1Se5O8miSh5P81hR9kuTjSXYm+UaSi/q2XZvkO81y7aAHIEk6Om2meg4A/66qHkjyGmBHkjur6pG+PlcC5zbLm4A/Bt6U5FTgemAMqGbf7VX13EBHIUlqbcYz/qp6pqoeaF6/ADwKrJ3UbRPwmeq5FzglyRrgCuDOqtrXhP2dwMaBjkCSdFSOao4/yXrgDcB9kzatBfq//zfRtE3XLkkaktbBn+Qk4PPAb1fV5O/6TXWnjzpC+1TvvyXJeJLxvXv3ti1LknSUWgV/kuX0Qv9Pq+oLU3SZANb1rZ8B7D5C+ytU1daqGquqsZGRVg+KlyTNQpuregJ8Cni0qj42TbftwHuaq3suAZ6vqmeA24HLk6xKsgq4vGmTJA1Jm6t6LgXeDTyU5MGm7XeBUYCquhH4InAVsBN4CXhfs21fko8C9zf73VBV+wZXviTpaM0Y/FX1v5l6rr6/TwEfmmbbNmDbrKqTJA2c39yVpI4x+CWpYwx+SeoYg1+SOsbgl6SOMfglqWMMfknqGINfkjrG4JekjjH4JaljDH5J6hiDX5I6xuCXpI4x+CWpYwx+SeoYg1+SOmbGB7Ek2Qb8c2BPVf38FNv/PfDrfe+3ARhpnr71d8ALwEHgQFWNDapwSdLstDnjvwnYON3GqvqDqrqwqi4Efgf46qTHK7612W7oS9IiMGPwV9U9QNvn5G4Gbp5TRZKkeTWwOf4kr6b3L4PP9zUXcEeSHUm2zLD/liTjScb37t07qLIkSZMM8o+7bwf+z6Rpnkur6iLgSuBDSd483c5VtbWqxqpqbGRkZIBlSZL6DTL4r2HSNE9V7W5+7gFuAy4e4OdJkmZhIMGf5GTgLcD/7Gs7MclrDr8GLge+OYjPkyTNXpvLOW8GLgNWJ5kArgeWA1TVjU23dwB3VNX/69v1dcBtSQ5/zmer6q8GV7okaTZmDP6q2tyiz030Lvvsb9sFvH62hUmS5off3JWkjjH4JaljDH5J6hiDX5I6xuCXpI4x+CWpYwx+SeoYg1+SOsbgl6SOMfglqWMMfknqGINfkjrG4JekjjH4JaljDH5J6pgZgz/JtiR7kkz59KwklyV5PsmDzfKRvm0bkzyWZGeSDw+ycEnS7LQ5478J2DhDn/9VVRc2yw0ASZYBn6D3oPXzgM1JzptLsZKkuZsx+KvqHmDfLN77YmBnVe2qqv3ALcCmWbyPJGmABjXH/4tJvp7kS0nOb9rWAk/19Zlo2iRJQzTjM3dbeAA4s6peTHIV8OfAuUCm6FvTvUmSLcAWgNHR0QGUJUmaypzP+Kvqh1X1YvP6i8DyJKvpneGv6+t6BrD7CO+ztarGqmpsZGRkrmVJkqYx5+BPcnqSNK8vbt7zWeB+4NwkZyVZAVwDbJ/r50mS5mbGqZ4kNwOXAauTTADXA8sBqupG4J3AbyQ5APwIuKaqCjiQ5DrgdmAZsK2qHp6XUUiSWksvoxeXsbGxGh8fH3YZkrRkJNlRVWNt+vrNXUnqGINfkjrG4JekjjH4JaljDH5J6hiDX5I6xuCXpI4x+CWpYwx+SeoYg1+SOsbgl6SOMfglqWMMfknqGINfkjrG4Jekjpkx+JNsS7InyTen2f7rSb7RLH+T5PV92/4uyUNJHkziDfYlaRFoc8Z/E7DxCNsfB95SVRcAHwW2Ttr+1qq6sO0DAiRJ82vGRy9W1T1J1h9h+9/0rd5L76HqkqRFatBz/O8HvtS3XsAdSXYk2TLgz5IkzcKMZ/xtJXkrveD/Z33Nl1bV7iSvBe5M8q2qumea/bcAWwBGR0cHVZYkaZKBnPEnuQD4b8Cmqnr2cHtV7W5+7gFuAy6e7j2qamtVjVXV2MjIyCDKkiRNYc7Bn2QU+ALw7qr6dl/7iUlec/g1cDkw5ZVBkqSFM+NUT5KbgcuA1UkmgOuB5QBVdSPwEeA04I+SABxoruB5HXBb03Y88Nmq+qt5GIMk6Si0uapn8wzbPwB8YIr2XcDrX7mHJGmY/OauJHWMwS9JHWPwS1LHGPyS1DEGvyR1jMEvSR1j8EtSxxj8ktQxBr8kdYzBL0kdY/BLUscY/JLUMQa/JHWMwS9JHWPwS1LHGPyS1DGtgj/JtiR7kkz56MT0fDzJziTfSHJR37Zrk3ynWa4dVOGSpNlpe8Z/E7DxCNuvBM5tli3AHwMkOZXeoxrfRO9B69cnWTXbYiVJc9cq+KvqHmDfEbpsAj5TPfcCpyRZA1wB3FlV+6rqOeBOjvwLRJI0zwY1x78WeKpvfaJpm65dkjQkgwr+TNFWR2h/5RskW5KMJxnfu3fvgMqSJE02qOCfANb1rZ8B7D5C+ytU1daqGquqsZGRkQGVJUmabFDBvx14T3N1zyXA81X1DHA7cHmSVc0fdS9v2iRJQ3J8m05JbgYuA1YnmaB3pc5ygKq6EfgicBWwE3gJeF+zbV+SjwL3N291Q1Ud6Y/EkqR51ir4q2rzDNsL+NA027YB246+NEnSfPCbu5LUMQa/JHWMwS9JHWPwS9KQvfjiizz99NP8+Mc/XpDPa/XHXUnS/Lj77ru56667AFi2bBnvete7OP/88+f1Mz3jl6QheeKJJ7jjjjtYs2YN69atY9WqVdx66628+OKL8/q5Br8kDcmuXbtYvnw5xx/fm3xZuXIlhw4d4umnn57XzzX4JWlITj75ZA4cOPCytkOHDnHiiSfO6+c6xy9JQ7JhwwZGRkZ48sknefWrX80LL7zAhg0bWLt2fm9ibPBL0pCsXLmSD37wgzzwwAPs3r2bc845hwsuuIBkqhsbD47BL0lDdNJJJ/HmN795QT/TOX5J6hiDX5I6xuCXpI4x+CWpY1oFf5KNSR5LsjPJh6fY/odJHmyWbyf5Qd+2g33btg+yeEnS0Zvxqp4ky4BPAL9M7xm69yfZXlWPHO5TVf+mr/+/Bt7Q9xY/qqoLB1eyJGku2pzxXwzsrKpdVbUfuAXYdIT+m4GbB1GcJGnw2gT/WuCpvvWJpu0VkpwJnAXc1dd8QpLxJPcm+ZVZVypJGog2X+Ca6itkNU3fa4DPVdXBvrbRqtqd5GzgriQPVdV3X/EhyRZgC8Do6GiLsiRJs9HmjH8CWNe3fgawe5q+1zBpmqeqdjc/dwFf4eXz//39tlbVWFWNjYyMtChLkjQbbYL/fuDcJGclWUEv3F9xdU6SfwKsAr7W17Yqyaua16uBS4FHJu8rSVo4M071VNWBJNcBtwPLgG1V9XCSG4Dxqjr8S2AzcEtV9U8DbQA+meQQvV8yv99/NZAkaeHl5Tm9OIyNjdX4+Piwy5CkJSPJjqoaa9PXb+5KUscY/JLUMQa/JHWMwS9JHWPwS1LHGPyS1DEGvyR1jMEvSR1j8EtSxxj8ktQxBr8kdYzBL0kdY/BLUscY/JLUMQa/JHWMwS9JHdMq+JNsTPJYkp1JPjzF9vcm2ZvkwWb5QN+2a5N8p1muHWTxkqSjN+OjF5MsAz4B/DK9B6/fn2T7FI9QvLWqrpu076nA9cAYUMCOZt/nBlK9JOmotTnjvxjYWVW7qmo/cAuwqeX7XwHcWVX7mrC/E9g4u1IlSYPQJvjXAk/1rU80bZP9WpJvJPlcknVHua8kaYG0Cf5M0Tb5Ce1/AayvqguAvwY+fRT79jomW5KMJxnfu3dvi7IkSbPRJvgngHV962cAu/s7VNWzVfWTZvVPgDe23bfvPbZW1VhVjY2MjLSpXZI0C22C/37g3CRnJVkBXANs7++QZE3f6tXAo83r24HLk6xKsgq4vGmTJA3JjFf1VNWBJNfRC+xlwLaqejjJDcB4VW0HfjPJ1cABYB/w3mbffUk+Su+XB8ANVbVvHsYhSWopVVNOuQ/V2NhYjY+PD7sMSVoykuyoqrE2ff3mriR1jMEvSR1j8EtSxxj8ktQxBr8kdYzBL0kdY/BLUscY/JLUMQa/JHWMwS9JHWPwS1LHGPyS1DEGvyR1zIy3ZV5S9u7tLaeeCqefPuxqJGlROnaC/8tf7i0JVMEll8Db395blyT9VKupniQbkzyWZGeSD0+x/d8meaR52PqXk5zZt+1gkgebZfvkfQfie9/rhf66dXDmmTA6Cl/7GjzxxLx8nCQtZTMGf5JlwCeAK4HzgM1JzpvU7f8CY83D1j8H/Oe+bT+qqgub5eoB1f1ye/b0zuyXLeutH3dc7/Uzz8zLx0nSUtbmjP9iYGdV7aqq/cAtwKb+DlV1d1W91KzeS++h6gtn1So4dKi3HHbwIJx22oKWIUlLQZvgXws81bc+0bRN5/3Al/rWT0gynuTeJL8yixpntnYtvPGNvamdiQl4/HHYsAF+9mfn5eMkaSlr88fdqf46OuWDepP8S2AMeEtf82hV7U5yNnBXkoeq6rtT7LsF2AIwOjraoqyX7Qy/+qtw4YWweze89rVwzjn/OPUjSfqpNsE/AazrWz8D2D25U5JfAv4D8Jaq+snh9qra3fzcleQrwBuAVwR/VW0FtkLvYevth9A47rhe2J9zzlHvKkld0maq537g3CRnJVkBXAO87OqcJG8APglcXVV7+tpXJXlV83o1cCnwyKCKlyQdvRnP+KvqQJLrgNuBZcC2qno4yQ3AeFVtB/4AOAn4H+ldN/9kcwXPBuCTSQ7R+yXz+1Vl8EvSEKXq6GdV5tvY2FiNj48PuwxJWjKS7KiqsTZ9vVePJHWMwS9JHWPwS1LHGPyS1DEGvyR1jMEvSR1j8Gte7T+4n++/9H32H9w/7FIkNY6dB7Fo0Xnoew9x27duY//B/axYtoJ3/NN38Auv+4VhlyV1nmf8mhfPvvQstz58Kye/6mRGTx7l5FedzK0P38q+H+0bdmlS5xn8mhdPPv8kh+oQK5evBGDl8pUcqkM8+fyTQ65MksGveXE48Cc74fgTFrgSSZM5x695cfaqs3ndia/jiR88wSknnMIPfvwDTj/xdM5edfawS5M6z+DXvFixbAXvv+j93Pf0fTz+3ONc9DMX8aa1b2LFshXDLk3qPINf8+akFSfxtrPeBmcNuxJJ/Zzjl6SOMfglqWNaBX+SjUkeS7IzyYen2P6qJLc22+9Lsr5v2+807Y8luWJwpUuSZmPG4E+yDPgEcCVwHrA5yXmTur0feK6qzgH+EPhPzb7n0XtG7/nARuCPmveTJA1JmzP+i4GdVbWrqvYDtwCbJvXZBHy6ef054G3pPXx3E3BLVf2kqh4HdjbvJ0kakjbBvxZ4qm99ommbsk9VHQCeB05rua8kaQG1Cf5M0Tb5Ce3T9Wmzb+8Nki1JxpOM7927t0VZkqTZaHMd/wSwrm/9DGD3NH0mkhwPnAzsa7kvAFW1FdgKkGRvkifaDGAaq4Hvz2H/xcJxLD7HyliOlXHAsTOWuY7jzLYd2wT//cC5Sc4Cnqb3x9p/ManPduBa4GvAO4G7qqqSbAc+m+RjwM8A5wJ/O9MHVtVI2wFMJcl4VY3N5T0WA8ex+BwrYzlWxgHHzlgWchwzBn9VHUhyHXA7sAzYVlUPJ7kBGK+q7cCngP+eZCe9M/1rmn0fTvJnwCPAAeBDVXVwnsYiSWqh1S0bquqLwBcntX2k7/WPgXdNs+/vAb83hxolSQN0rH5zd+uwCxgQx7H4HCtjOVbGAcfOWBZsHKma8iIbSdIx6lg945ckTWPJBv9c7h+02LQYy3ubS1wfbJYPDKPOmSTZlmRPkm9Osz1JPt6M8xtJLlroGttoMY7Lkjzfdzw+MlW/YUuyLsndSR5N8nCS35qiz1I5Jm3GsuiPS5ITkvxtkq834/iPU/SZ/+yqqiW30Lu66LvA2cAK4OvAeZP6/Cvgxub1NcCtw657DmN5L/Bfh11ri7G8GbgI+OY0268CvkTvi32XAPcNu+ZZjuMy4C+HXWeLcawBLmpevwb49hT/21oqx6TNWBb9cWn+O5/UvF4O3AdcMqnPvGfXUj3jn8v9gxabNmNZEqrqHnqX805nE/CZ6rkXOCXJmoWprr0W41gSquqZqnqgef0C8CivvGXKUjkmbcay6DX/nV9sVpc3y+Q/tM57di3V4J/L/YMWm7b3M/q15p/in0uybortS8GxdO+mX2z+uf6lJOcPu5iZNNMFb6B3htlvyR2TI4wFlsBxSbIsyYPAHuDOqpr2mMxXdi3V4J/L/YMWmzZ1/gWwvqouAP6afzwbWGqWyjGZyQPAmVX1euC/AH8+5HqOKMlJwOeB366qH07ePMUui/aYzDCWJXFcqupgVV1I7xY2Fyf5+Uld5v2YLNXgP5r7BzHp/kGLzYxjqapnq+onzeqfAG9coNoGrfW9mxazqvrh4X+uV+/LjcuTrB5yWVNKspxeUP5pVX1hii5L5pjMNJaldFwAquoHwFfoPauk37xn11IN/p/ePyjJCnp/ANk+qc/h+wdB3/2DFrDGtmYcy6Q516vpzW8uRduB9zRXklwCPF9Vzwy7qKOV5PTDc65JLqb3/6Nnh1vVKzU1fgp4tKo+Nk23JXFM2oxlKRyXJCNJTmlerwR+CfjWpG7znl2tbtmw2NQc7h+02LQcy28muZre/Y720bvKZ9FJcjO9KytWJ5kArqf3xyuq6kZ6t/24it4DeV4C3jecSo+sxTjeCfxGkgPAj4BrFulJxaXAu4GHmjllgN8FRmFpHRPajWUpHJc1wKfTexLhccCfVdVfLnR2+c1dSeqYpTrVI0maJYNfkjrG4JekjjH4JaljDH5J6hiDX5I6xuCXpI4x+CWpY/4/sgiXEx6tX4gAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练前的输出\n", + "pY=sess.run(ff.output,feed_dict={ff.inputs:X.reshape((4,2)),ff.drop_keep_rate:1.0})\n", + "print(pY)\n", + "plt.scatter([0,1,2,3],pY,color=['red','green','blue','black'],s=25,alpha=0.4,marker='o')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.1 0.1 ]\n", + " [ 0. 0. ]\n", + " [ 0.6051594 1.28755772]\n", + " [ 0.23883221 0.50023252]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练前隐藏层的输出\n", + "pY=sess.run(ff.hid_layers[0],feed_dict={ff.inputs:X.reshape((4,2)),ff.drop_keep_rate:1.0})\n", + "print(pY)\n", + "plt.scatter(pY[:,0],pY[:,1],color=['red','green','blue','black'],s=25,alpha=0.4,marker='o')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# 训练并记录\n", + "k=0.0\n", + "for i in range(10000):\n", + " k+=1\n", + " summary, _ = sess.run([merged,ff.train_step],feed_dict={ff.inputs:X.reshape((4,2)),ff.labels:Y.reshape((4,1)),ff.drop_keep_rate:1.0})\n", + " train_writer.add_summary(summary, k)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W_0:\n", + "[[ 0.03714262 0.29223838]\n", + " [-0.03218493 -0.29465774]]\n", + "W_1:\n", + "[[ 0.4100056]\n", + " [ 2.2319622]]\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(4,2.5,u'2.23')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练后的权重\n", + "\n", + "W0=sess.run(ff.W[0])\n", + "W1=sess.run(ff.W[1])\n", + "print('W_0:\\n%s' %sess.run(ff.W[0]))\n", + "print('W_1:\\n%s' %sess.run(ff.W[1]))\n", + "\n", + "plt.scatter([1,1,5],[1,3,2],color=['red','red','blue'],s=200,alpha=0.4,marker='o')\n", + "plt.scatter([3,3],[1,3],color=['green','green'],s=200,alpha=0.4,marker='o')\n", + "\n", + "plt.plot([1,3],[1,1],color='orange',linewidth=abs(W0[0,0]))\n", + "plt.annotate('%0.2f' %W0[0,0],xy=(2, 1.0))\n", + "\n", + "plt.plot([1,3],[3,1],color='blue',linewidth=abs(W0[1,0]))\n", + "plt.annotate('%0.2f' %W0[1,0],xy=(1.5, 1.5))\n", + "\n", + "plt.plot([1,3],[1,3],color='blue',linewidth=abs(W0[0,1]))\n", + "plt.annotate('%0.2f' %W0[0,1],xy=(1.5, 2.5))\n", + "\n", + "plt.plot([1,3],[3,3],color='orange',linewidth=abs(W0[1,1]))\n", + "plt.annotate('%0.2f' %W0[1,1],xy=(2, 3))\n", + "\n", + "plt.plot([3,5],[1,2],color='blue',linewidth=abs(W1[0]))\n", + "plt.annotate('%0.2f' %W1[0],xy=(4, 1.5))\n", + "\n", + "plt.plot([3,5],[3,2],color='blue',linewidth=abs(W1[1]))\n", + "plt.annotate('%0.2f' %W1[1],xy=(4, 2.5))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.33375549]\n", + " [ 0.33375549]\n", + " [ 0.99873507]\n", + " [ 0.33375549]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练后的输出\n", + "pY=sess.run(ff.output,feed_dict={ff.inputs:X.reshape((4,2)),ff.drop_keep_rate:1.0})\n", + "print(pY)\n", + "plt.scatter([0,1,2,3],pY,color=['red','green','blue','black'],s=25,alpha=0.4,marker='o')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0. 0. ]\n", + " [ 0. 0. ]\n", + " [ 0.03147838 0.29215246]\n", + " [ 0. 0. ]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 训练后隐藏层的输出\n", + "pY=sess.run(ff.hid_layers[0],feed_dict={ff.inputs:X.reshape((4,2)),ff.drop_keep_rate:1.0})\n", + "\n", + "print(pY)\n", + "plt.scatter(pY[:,0],pY[:,1],color=['red','green','blue','black'],s=25,alpha=0.4,marker='o')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([[-0.82895017, 0.82891428],\n", + " [ 0.82915729, -0.82918972]], dtype=float32), array([[ 1.17231631],\n", + " [ 1.1722393 ]], dtype=float32), array([ 0., 0.], dtype=float32), array([ 0.], dtype=float32)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 该操作可以用于读取已经训练好的权重W和b\n", + "# 每层W想要读取的值\n", + "W_0=np.array([[-0.82895017,0.82891428],[ 0.82915729,-0.82918972]],dtype='float32')\n", + "W_1=np.array([[ 1.17231631],[ 1.1722393 ]],dtype='float32')\n", + "# 每层b想要读取的值\n", + "b_0=np.array([0,0],dtype='float32')\n", + "b_1=np.array([0],dtype='float32')\n", + "# 读取ops\n", + "reload1=tf.assign(ff.W[0],W_0)\n", + "reload2=tf.assign(ff.W[1],W_1)\n", + "reload3=tf.assign(ff.b[0],b_0)\n", + "reload4=tf.assign(ff.b[1],b_1)\n", + "# 执行ops\n", + "sess.run([reload1,reload2,reload3,reload4])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#用完关闭session\n", + "sess.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.14" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/.ipynb_checkpoints/core_code-checkpoint.ipynb b/.ipynb_checkpoints/core_code-checkpoint.ipynb new file mode 100644 index 0000000..8e27453 --- /dev/null +++ b/.ipynb_checkpoints/core_code-checkpoint.ipynb @@ -0,0 +1,159 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "tf.set_random_seed(55)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#构建网络\n", + "D_input = 2\n", + "D_label = 1\n", + "D_hidden = 2\n", + "lr=1e-4\n", + "\n", + "x = tf.placeholder(tf.float32, [None, D_input], name=\"x\")\n", + "t = tf.placeholder(tf.float32, [None, D_label], name=\"t\")\n", + " \n", + "W_h1 = tf.Variable(tf.truncated_normal([D_input, D_hidden], stddev=0.1), name=\"W_h\")\n", + "b_h1 = tf.Variable(tf.constant(0.1, shape=[D_hidden]), name=\"b_h\")\n", + "pre_act_h1 = tf.matmul(x, W_h1) + b_h1\n", + "act_h1 = tf.nn.relu(pre_act_h1, name='act_h')\n", + " \n", + "W_o = tf.Variable(tf.truncated_normal([D_hidden, D_label], stddev=0.1), name=\"W_o\")\n", + "b_o = tf.Variable(tf.constant(0.1, shape=[D_label]), name=\"b_o\")\n", + "pre_act_o = tf.matmul(act_h1, W_o) + b_o\n", + "y = tf.nn.relu(pre_act_o, name='act_y')\n", + " \n", + "loss=tf.reduce_mean((y-t)**2)\n", + " \n", + "train_step = tf.train.AdamOptimizer(lr).minimize(loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#生成数据\n", + "X=[[0,0],[0,1],[1,0],[1,1]]\n", + "Y=[[0],[1],[1],[0]]\n", + "X=np.array(X).astype('int16')\n", + "Y=np.array(Y).astype('int16')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "#加载\n", + "sess = tf.InteractiveSession()\n", + "sess.run(tf.global_variables_initializer())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#训练\n", + "for i in range(20000):\n", + " sess.run(train_step,feed_dict={x:X,t:Y} )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.01419991],\n", + " [ 0.97204113],\n", + " [ 0.97204131],\n", + " [ 0.04118853]], dtype=float32)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#计算预测值\n", + "sess.run(y,feed_dict={x:X})" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.96414495, 1.01730847],\n", + " [ 0. , 0.50864619],\n", + " [ 0. , 0.50864631],\n", + " [ 0. , 0. ]], dtype=float32)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#查看隐藏层的输出\n", + "sess.run(act_h1,feed_dict={x:X})" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "#用完关闭session\n", + "sess.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.14" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/FNN.py b/FNN.py index 360aa91..939ca05 100644 --- a/FNN.py +++ b/FNN.py @@ -66,13 +66,13 @@ def bias_init(self,shape): def variable_summaries(self, var, name): with tf.name_scope(name+'_summaries'): mean = tf.reduce_mean(var) - tf.scalar_summary('mean/' + name, mean) + tf.summary.scalar('mean/' + name, mean) with tf.name_scope(name+'_stddev'): stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean))) - tf.scalar_summary('_stddev/' + name, stddev) - tf.scalar_summary('_max/' + name, tf.reduce_max(var)) - tf.scalar_summary('_min/' + name, tf.reduce_min(var)) - tf.histogram_summary(name, var) + tf.summary.scalar('_stddev/' + name, stddev) + tf.summary.scalar('_max/' + name, tf.reduce_max(var)) + tf.summary.scalar('_min/' + name, tf.reduce_min(var)) + tf.summary.histogram(name, var) def layer(self,in_tensor, in_dim, out_dim, layer_name, act=tf.nn.relu): with tf.name_scope(layer_name): @@ -85,9 +85,9 @@ def layer(self,in_tensor, in_dim, out_dim, layer_name, act=tf.nn.relu): self.variable_summaries(biases, layer_name + '/biases') with tf.name_scope(layer_name+'_Wx_plus_b'): pre_activate = tf.matmul(in_tensor, weights) + biases - tf.histogram_summary(layer_name + '/pre_activations', pre_activate) + tf.summary.histogram(layer_name + '/pre_activations', pre_activate) activations = act(pre_activate, name='activation') - tf.histogram_summary(layer_name + '/activations', activations) + tf.summary.histogram(layer_name + '/activations', activations) return activations, tf.nn.l2_loss(weights) def drop_layer(self,in_tensor): @@ -129,25 +129,25 @@ def build(self, prefix): with tf.name_scope('total_l2'): for l2 in self.total_l2: self.l2_penalty+=l2 - tf.scalar_summary('l2_penalty', self.l2_penalty) + tf.summary.scalar_('l2_penalty', self.l2_penalty) if self.Task_type=='regression': with tf.name_scope('SSE'): self.loss=tf.reduce_mean(tf.nn.l2_loss((self.output - self.labels))) - tf.scalar_summary('loss', self.loss) + tf.summary.scalar('loss', self.loss) else: entropy = tf.nn.softmax_cross_entropy_with_logits(logits=self.output, labels=self.labels) with tf.name_scope('cross entropy'): self.loss = tf.reduce_mean(entropy) - tf.scalar_summary('loss', self.loss) + tf.summary.scalar('loss', self.loss) with tf.name_scope('accuracy'): correct_prediction = tf.equal(tf.argmax(self.output, 1), tf.argmax(self.labels, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) - tf.scalar_summary('accuracy', self.accuracy) + tf.summary.scalar('accuracy', self.accuracy) with tf.name_scope('total_loss'): self.total_loss=self.loss + self.l2_penalty*self.L2_lambda - tf.scalar_summary('total_loss', self.total_loss) + tf.summary.scalar_('total_loss', self.total_loss) #train with tf.name_scope('train'): diff --git a/LV3.ipynb b/LV3.ipynb index c56d791..db9d9e1 100644 --- a/LV3.ipynb +++ b/LV3.ipynb @@ -11,15 +11,14 @@ "import tensorflow as tf\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "%matplotlib inline\n", + "tf.reset_default_graph()" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class FNN(object):\n", @@ -86,14 +85,14 @@ " def variable_summaries(self, var, name):\n", " with tf.name_scope(name+'_summaries'):\n", " mean = tf.reduce_mean(var)\n", - " tf.scalar_summary('mean/' + name, mean)\n", + " tf.summary.scalar('mean/' + name, mean)\n", " with tf.name_scope(name+'_stddev'):\n", " stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))\n", " # 记录每次训练后变量的数值变化\n", - " tf.scalar_summary('_stddev/' + name, stddev)\n", - " tf.scalar_summary('_max/' + name, tf.reduce_max(var))\n", - " tf.scalar_summary('_min/' + name, tf.reduce_min(var))\n", - " tf.histogram_summary(name, var)\n", + " tf.summary.scalar('_stddev/' + name, stddev)\n", + " tf.summary.scalar_('_max/' + name, tf.reduce_max(var))\n", + " tf.summary.scalar_('_min/' + name, tf.reduce_min(var))\n", + " tf.summary.histogram(name, var)\n", "\n", " def layer(self,in_tensor, in_dim, out_dim, layer_name, act=tf.nn.relu):\n", " with tf.name_scope(layer_name):\n", @@ -113,10 +112,10 @@ " # 计算Wx+b\n", " pre_activate = tf.matmul(in_tensor, weights) + biases\n", " # 记录直方图\n", - " tf.histogram_summary(layer_name + '/pre_activations', pre_activate)\n", + " tf.summary.histogram(layer_name + '/pre_activations', pre_activate)\n", " # 计算a(Wx+b)\n", " activations = act(pre_activate, name='activation')\n", - " tf.histogram_summary(layer_name + '/activations', activations)\n", + " tf.summary.histogram(layer_name + '/activations', activations)\n", " # 最终返回该层的输出,以及权重W的L2\n", " return activations, tf.nn.l2_loss(weights)\n", "\n", @@ -174,7 +173,7 @@ " with tf.name_scope('total_l2'):\n", " for l2 in self.total_l2:\n", " self.l2_penalty+=l2\n", - " tf.scalar_summary('l2_penalty', self.l2_penalty)\n", + " tf.summary.scalar('l2_penalty', self.l2_penalty)\n", " \n", " # 不同任务的loss\n", " # 若为回归,则loss是用于判断所有预测值和实际值差别的函数。\n", @@ -183,22 +182,22 @@ " self.loss=tf.reduce_mean((self.output-self.labels)**2)\n", " self.loss2=tf.nn.l2_loss(self.output-self.labels)\n", " \n", - " tf.scalar_summary('loss', self.loss)\n", + " tf.summary.scalar('loss', self.loss)\n", " else:\n", " # 若为分类,cross entropy的loss function\n", " entropy = tf.nn.softmax_cross_entropy_with_logits(self.output, self.labels)\n", " with tf.name_scope('cross entropy'):\n", " self.loss = tf.reduce_mean(entropy)\n", - " tf.scalar_summary('loss', self.loss)\n", + " tf.summary.scalar('loss', self.loss)\n", " with tf.name_scope('accuracy'):\n", " correct_prediction = tf.equal(tf.argmax(self.output, 1), tf.argmax(self.labels, 1))\n", " self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n", - " tf.scalar_summary('accuracy', self.accuracy)\n", + " tf.summary.scalar('accuracy', self.accuracy)\n", " \n", " # 整合所有loss,形成最终loss\n", " with tf.name_scope('total_loss'):\n", " self.total_loss=self.loss + self.l2_penalty*self.L2_lambda\n", - " tf.scalar_summary('total_loss', self.total_loss)\n", + " tf.summary.scalar('total_loss', self.total_loss)\n", " \n", " # 训练操作\n", " with tf.name_scope('train'):\n", @@ -263,9 +262,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -282,9 +279,7 @@ { "cell_type": "code", "execution_count": 6, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -319,18 +314,16 @@ "outputs": [], "source": [ "sess = tf.InteractiveSession()\n", - "tf.initialize_all_variables().run()\n", - "merged = tf.merge_all_summaries()\n", - "train_writer = tf.train.SummaryWriter('log3' + '/train',sess.graph)\n", - "test_writer = tf.train.SummaryWriter('log3' + '/test')" + "sess.run(tf.global_variables_initializer())\n", + "merged = tf.summary.merge_all()\n", + "train_writer = tf.summary.FileWriter('log3' + '/train',sess.graph)\n", + "test_writer = tf.summary.FileWriter('log3' + '/test')" ] }, { "cell_type": "code", "execution_count": 8, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "def plots(T,P,i, n=21,length=400):\n", @@ -360,7 +353,6 @@ "cell_type": "code", "execution_count": 9, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [ @@ -439,6 +431,16 @@ " test_writer.add_summary(summary, k)\n", " print('epoch%s | train_loss:%s |test_loss:%s' %(i,sess.run(ff.loss,feed_dict={ff.inputs:X0,ff.labels:Y0,ff.drop_keep_rate:1.0}),sess.run(ff.loss,feed_dict={ff.inputs:X_test,ff.labels:Y_test,ff.drop_keep_rate:1.0})))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#用完关闭session\n", + "sess.close()" + ] } ], "metadata": { @@ -457,7 +459,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", - "version": "2.7.12" + "version": "2.7.14" } }, "nbformat": 4, diff --git a/LV3_0.12.ipynb b/LV3_0.12.ipynb index 2e6a763..2484451 100644 --- a/LV3_0.12.ipynb +++ b/LV3_0.12.ipynb @@ -3,23 +3,20 @@ { "cell_type": "code", "execution_count": 1, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "import tensorflow as tf\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "%matplotlib inline\n", + "tf.reset_default_graph()" ] }, { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "class FNN(object):\n", @@ -222,9 +219,7 @@ { "cell_type": "code", "execution_count": 3, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "def Standardize(seq):\n", @@ -245,9 +240,7 @@ { "cell_type": "code", "execution_count": 4, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [], "source": [ "mfc=np.load('X.npy')\n", @@ -269,9 +262,7 @@ { "cell_type": "code", "execution_count": 5, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -287,9 +278,8 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [ @@ -410,14 +400,12 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ "sess = tf.InteractiveSession()\n", - "tf.global_variables_initializer().run()\n", + "sess.run(tf.global_variables_initializer())\n", "merged = tf.summary.merge_all()\n", "train_writer = tf.summary.FileWriter('log' + '/train',sess.graph)\n", "test_writer = tf.summary.FileWriter('log' + '/test')" @@ -425,10 +413,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "def plots(T,P,i, n=21,length=400):\n", @@ -456,9 +442,8 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { - "collapsed": false, "scrolled": true }, "outputs": [ @@ -466,16 +451,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "epoch0 | train_loss:[0.60085243] |test_loss:0.659336\n", - "epoch1 | train_loss:[0.56255817] |test_loss:0.653993\n", - "epoch2 | train_loss:[0.53966987] |test_loss:0.644001\n", - "epoch3 | train_loss:[0.47888839] |test_loss:0.609307\n", - "epoch4 | train_loss:[0.4274255] |test_loss:0.580894\n", - "epoch5 | train_loss:[0.41663638] |test_loss:0.58645\n", - "epoch6 | train_loss:[0.39932683] |test_loss:0.594072\n", - "epoch7 | train_loss:[0.35524291] |test_loss:0.57222\n", - "epoch8 | train_loss:[0.35336751] |test_loss:0.565518\n", - "epoch9 | train_loss:[0.30439419] |test_loss:0.545433\n" + "epoch0 | train_loss:[0.85698944] |test_loss:0.849185\n", + "epoch1 | train_loss:[0.75586188] |test_loss:0.74935\n", + "epoch2 | train_loss:[0.66804069] |test_loss:0.697456\n", + "epoch3 | train_loss:[0.59767956] |test_loss:0.649171\n", + "epoch4 | train_loss:[0.57731116] |test_loss:0.652371\n", + "epoch5 | train_loss:[0.5061782] |test_loss:0.596573\n", + "epoch6 | train_loss:[0.46441522] |test_loss:0.595333\n", + "epoch7 | train_loss:[0.40969208] |test_loss:0.555003\n", + "epoch8 | train_loss:[0.40397146] |test_loss:0.573359\n" ] } ], @@ -503,9 +487,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "#用完关闭session\n", @@ -529,7 +511,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", - "version": "2.7.12" + "version": "2.7.14" } }, "nbformat": 4, diff --git a/RNN/.DS_Store b/RNN/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0