推荐设备MORE

济南建H5网站定制—【qq号申请

济南建H5网站定制—【qq号申请

新闻资讯

大连企业网站建设条件—如何从微信监管你的T

日期:2021-02-10
我要分享

雷锋网按:原文中写作者,原文中整理创作者在发布的文章内容內容《》,雷锋网(手机微信微信公众号:雷锋网)获其授权发布。

之前答复难点【】的状况下,说到可以用力机手机微信来管着训练,完全不用守着。
[标识:內容1]
意想不到那麼受欢迎……

原难点下的答复下列

不知道道道有哪些朋友是在TF/keras/chainer/mxnet等构架下要python撸的….…

这可是python啊……上itchat,弄个手机上手机微信号加本身为朋友(或者本身发本身),训练进展追随一路发送邮件息给自己就可以了了,做了可视性性化的话顺便把图也一分布式系统回家。

接着便可以温馨入眠/逛街/撩妹/写回应了。

讲大路理,甚至简单的关键主要参数调整都可以以以冲着用劲机来……

大概具体实际效果下列

当然可以做得更多方位一些。最可靠的方式自然是坚决地做一个http服务或者一个rpc,可是那般一般太麻烦。秉着简单高效率率的规范,几行编号能具备具体实际效果方便快捷本身当然是最好的,联接手机上手机微信或者web真就是十分好的选择了。只是查寻的话,TensorBoard就十分好,但是倘若想加上一些自定具体实际操作,还是独立定制的。echat.js做成web,或者itchat做着手机手机微信服务,都是挺不赖的选择。    

文章内容文章正文下列

这儿瞎瞎折腾一个例子。以TensorFlow的example中,应用CNN处理MNIST的程序为例子子,大伙儿做一点点小小的的的修改。

最开始这儿放上写完的编号:

#!/usr/bin/env python
# coding: utf-8


A Convolutional Network implementation example using TensorFlow library.
This example is using the MNIST database of handwritten digits
(yann.lecun/exdb/mnist/)
Author: Aymeric Damien
Project: github/aymericdamien/TensorFlow-Examples/


Add a itchat controller with multi thread


from __future__ import print_function

import tensorflow as tf

# Import MNIST data
from tensorflow.examples.tutorials.mnist import input_data

# Import itchat threading
import itchat
import threading

# Create a running status flag
lock = threading.Lock()
running = False

# Parameters
learning_rate = 0.001
training_iters = 200000
batch_size = 128
display_step = 10

def nn_train(wechat_name, param):
   global lock, running
   # Lock
   with lock:
       running = True

   # mnist data reading
   mnist = input_data.read_data_sets( data/ , one_hot=True)

   # Parameters
   # learning_rate = 0.001
   # training_iters = 200000
   # batch_size = 128
   # display_step = 10
   learning_rate, training_iters, batch_size, display_step = param

   # Network Parameters
   n_input = 784 # MNIST data input (img shape: 28*28)
   n_classes = 10 # MNIST total classes (0-9 digits)
   dropout = 0.75 # Dropout, probability to keep units

   # tf Graph input
   x = tf.placeholder(tf.float32, [None, n_input])
   y = tf.placeholder(tf.float32, [None, n_classes])
   keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)


   # Create some wrappers for simplicity
   def conv2d(x, W, b, strides=1):
       # Conv2D wrapper, with bias and relu activation
       x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding= SAME )
       x = tf.nn.bias_add(x, b)
       return tf.nn.relu(x)


   def maxpool2d(x, k=2):
       # MaxPool2D wrapper
       return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
                           padding= SAME )


   # Create model
   def conv_net(x, weights, biases, dropout):
       # Reshape input picture
       x = tf.reshape(x, shape=[-1, 28, 28, 1])

       # Convolution Layer
       conv1 = conv2d(x, weights[ wc1 ], biases[ bc1 ])
       # Max Pooling (down-sampling)
       conv1 = maxpool2d(conv1, k=2)

       # Convolution Layer
       conv2 = conv2d(conv1, weights[ wc2 ], biases[ bc2 ])
       # Max Pooling (down-sampling)
       conv2 = maxpool2d(conv2, k=2)

       # Fully connected layer
       # Reshape conv2 output to fit fully connected layer input
       fc1 = tf.reshape(conv2, [-1, weights[ wd1 ].get_shape().as_list()[0]])
       fc1 = tf.add(tf.matmul(fc1, weights[ wd1 ]), biases[ bd1 ])
       fc1 = tf.nn.relu(fc1)
       # Apply Dropout
       fc1 = tf.nn.dropout(fc1, dropout)

       # Output, class prediction
       out = tf.add(tf.matmul(fc1, weights[ out ]), biases[ out ])
       return out

   # Store layers weight bias
   weights = {
       # 5x5 conv, 1 input, 32 outputs
        wc1 : tf.Variable(tf.random_normal([5, 5, 1, 32])),
       # 5x5 conv, 32 inputs, 64 outputs
        wc2 : tf.Variable(tf.random_normal([5, 5, 32, 64])),
       # fully connected, 7*7*64 inputs, 1024 outputs
        wd1 : tf.Variable(tf.random_normal([7*7*64, 1024])),
       # 1024 inputs, 10 outputs (class prediction)
        out : tf.Variable(tf.random_normal([1024, n_classes]))
   }

   biases = {
        bc1 : tf.Variable(tf.random_normal([32])),
        bc2 : tf.Variable(tf.random_normal([64])),
        bd1 : tf.Variable(tf.random_normal([1024])),
        out : tf.Variable(tf.random_normal([n_classes]))
   }

   # Construct model
   pred = conv_net(x, weights, biases, keep_prob)

   # Define loss and optimizer
   cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
   optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

   # Evaluate model
   correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
   accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))


   # Initializing the variables
   init = tf.global_variables_initializer()

   # Launch the graph
   with tf.Session() as sess:
       sess.run(init)
       step = 1
       # Keep training until reach max iterations
       print( Wait for lock )
       with lock:
           run_state = running
       print( Start )
       while step * batch_size training_iters and run_state:
           batch_x, batch_y = mnist.train.next_batch(batch_size)
           # Run optimization op (backprop)
           sess.run(optimizer, feed_dict={x: batch_x, y: batch_y,
                                       keep_prob: dropout})
           if step % display_step == 0:
               # Calculate batch loss and accuracy
               loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,
                                                               y: batch_y,
                                                               keep_prob: 1.})
               print( Iter + str(step*batch_size) + , Minibatch Loss= + \
                    {:.6f} .format(loss) + , Training Accuracy= + \
                    {:.5f} .format(acc))
               itchat.send( Iter + str(step*batch_size) + , Minibatch Loss= + \
                    {:.6f} .format(loss) + , Training Accuracy= + \
                            {:.5f} .format(acc), wechat_name)
           step += 1
           with lock:
               run_state = running
       print( Optimization Finished! )
       itchat.send( Optimization Finished! , wechat_name)

       # Calculate accuracy for 256 mnist test images
       print( Testing Accuracy: , \
           sess.run(accuracy, feed_dict={x: mnist.test.images[:256],
                                       y: mnist.test.labels[:256],
                                       keep_prob: 1.}))
       itchat.send( Testing Accuracy: %s %
           sess.run(accuracy, feed_dict={x: mnist.test.images[:256],
                                       y: mnist.test.labels[:256],
                                         keep_prob: 1.}), wechat_name)

   with lock:
       running = False

@itchat.msg_register([itchat.content.TEXT])
def chat_trigger(msg):
   global lock, running, learning_rate, training_iters, batch_size, display_step
   if msg[ Text ] == u 一开始 :
       print( Starting )
       with lock:
           run_state = running
       if not run_state:
           try:
               threading.Thread(target=nn_train, args=(msg[ FromUserName ], (learning_rate, training_iters, batch_size, display_step))).start()
           except:
               msg.reply( Running )
   elif msg[ Text ] == u 停止 :
       print( Stopping )
       with lock:
           running = False
   elif msg[ Text ] == u 关键主要参数 :
       itchat.send( lr=%f, ti=%d, bs=%d, ds=%d %(learning_rate, training_iters, batch_size, display_step),msg[ FromUserName ])
   else:
       try:
           param = msg[ Text ].split()
           key, value = param
           print(key, value)
           if key == lr :
               learning_rate = float(value)
           elif key == ti :
               training_iters = int(value)
           elif key == bs :
               batch_size = int(value)
           elif key == ds :
               display_step = int(value)
       except:
           pass


if __name__ == __main__ :
   itchat.auto_login(hotReload=True)
   itchat.run()

这一段编号里面,我所做的修改重要是:

0.导进了itchat和threading

1. 把原本的脚本制作制作里互连网构成和训练的一一部分甩赶到一个涵数nn_train里

def nn_train(wechat_name, param):
   global lock, running
   # Lock
   with lock:
       running = True

   # mnist data reading
   mnist = input_data.read_data_sets( data/ , one_hot=True)

   # Parameters
   # learning_rate = 0.001
   # training_iters = 200000
   # batch_size = 128
   # display_step = 10
   learning_rate, training_iters, batch_size, display_step = param

   # Network Parameters
   n_input = 784 # MNIST data input (img shape: 28*28)
   n_classes = 10 # MNIST total classes (0-9 digits)
   dropout = 0.75 # Dropout, probability to keep units

   # tf Graph input
   x = tf.placeholder(tf.float32, [None, n_input])
   y = tf.placeholder(tf.float32, [None, n_classes])
   keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)


   # Create some wrappers for simplicity
   def conv2d(x, W, b, strides=1):
       # Conv2D wrapper, with bias and relu activation
       x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding= SAME )
       x = tf.nn.bias_add(x, b)
       return tf.nn.relu(x)


   def maxpool2d(x, k=2):
       # MaxPool2D wrapper
       return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
                           padding= SAME )


   # Create model
   def conv_net(x, weights, biases, dropout):
       # Reshape input picture
       x = tf.reshape(x, shape=[-1, 28, 28, 1])

       # Convolution Layer
       conv1 = conv2d(x, weights[ wc1 ], biases[ bc1 ])
       # Max Pooling (down-sampling)
       conv1 = maxpool2d(conv1, k=2)

       # Convolution Layer
       conv2 = conv2d(conv1, weights[ wc2 ], biases[ bc2 ])
       # Max Pooling (down-sampling)
       conv2 = maxpool2d(conv2, k=2)

       # Fully connected layer
       # Reshape conv2 output to fit fully connected layer input
       fc1 = tf.reshape(conv2, [-1, weights[ wd1 ].get_shape().as_list()[0]])
       fc1 = tf.add(tf.matmul(fc1, weights[ wd1 ]), biases[ bd1 ])
       fc1 = tf.nn.relu(fc1)
       # Apply Dropout
       fc1 = tf.nn.dropout(fc1, dropout)

       # Output, class prediction
       out = tf.add(tf.matmul(fc1, weights[ out ]), biases[ out ])
       return out

   # Store layers weight bias
   weights = {
       # 5x5 conv, 1 input, 32 outputs
        wc1 : tf.Variable(tf.random_normal([5, 5, 1, 32])),
       # 5x5 conv, 32 inputs, 64 outputs
        wc2 : tf.Variable(tf.random_normal([5, 5, 32, 64])),
       # fully connected, 7*7*64 inputs, 1024 outputs
        wd1 : tf.Variable(tf.random_normal([7*7*64, 1024])),
       # 1024 inputs, 10 outputs (class prediction)
        out : tf.Variable(tf.random_normal([1024, n_classes]))
   }

   biases = {
        bc1 : tf.Variable(tf.random_normal([32])),
        bc2 : tf.Variable(tf.random_normal([64])),
        bd1 : tf.Variable(tf.random_normal([1024])),
        out : tf.Variable(tf.random_normal([n_classes]))
   }

   # Construct model
   pred = conv_net(x, weights, biases, keep_prob)

   # Define loss and optimizer
   cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
   optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

   # Evaluate model
   correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
   accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))


   # Initializing the variables
   init = tf.global_variables_initializer()

   # Launch the graph
   with tf.Session() as sess:
       sess.run(init)
       step = 1
       # Keep training until reach max iterations
       print( Wait for lock )
       with lock:
           run_state = running
       print( Start )
       while step * batch_size training_iters and run_state:
           batch_x, batch_y = mnist.train.next_batch(batch_size)
           # Run optimization op (backprop)
           sess.run(optimizer, feed_dict={x: batch_x, y: batch_y,
                                       keep_prob: dropout})
           if step % display_step == 0:
               # Calculate batch loss and accuracy
               loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,
                                                               y: batch_y,
                                                               keep_prob: 1.})
               print( Iter + str(step*batch_size) + , Minibatch Loss= + \
                    {:.6f} .format(loss) + , Training Accuracy= + \
                    {:.5f} .format(acc))
               itchat.send( Iter + str(step*batch_size) + , Minibatch Loss= + \
                    {:.6f} .format(loss) + , Training Accuracy= + \
                            {:.5f} .format(acc), wechat_name)
           step += 1
           with lock:
               run_state = running
       print( Optimization Finished! )
       itchat.send( Optimization Finished! , wechat_name)

       # Calculate accuracy for 256 mnist test images
       print( Testing Accuracy: , \
           sess.run(accuracy, feed_dict={x: mnist.test.images[:256],
                                       y: mnist.test.labels[:256],
                                       keep_prob: 1.}))
       itchat.send( Testing Accuracy: %s %
           sess.run(accuracy, feed_dict={x: mnist.test.images[:256],
                                       y: mnist.test.labels[:256],
                                         keep_prob: 1.}), wechat_name)

   with lock:
       running = False

这儿大部分分分是跟原本的编号一样的,可是最开始所有print的地域都加了个itchat.send来输出系统软件系统日志,此外加了个带锁的状况量running用以做运行开关电源电源开关。此外,一一部分关键主要参数是依据涵数关键主要参数传入的。

接着呢,写了个itchat的handler

@itchat.msg_register([itchat.content.TEXT])
def chat_trigger(msg):
   global lock, running, learning_rate, training_iters, batch_size, display_step
   if msg[ Text ] == u 一开始 :
       print( Starting )
       with lock:
           run_state = running
       if not run_state:
           try:
               threading.Thread(target=nn_train, args=(msg[ FromUserName ], (learning_rate, training_iters, batch_size, display_step))).start()
           except:
               msg.reply( Running )

作用是,倘若收到手机上手机微信信息内容,内容为『一开始』,那麼就跑训练的涵数(当然,便于防止阻塞,放进了此外一个过程里)

最后再在脚本制作制作时兴程里运用itchat登录手机上手机微信并且启动itchat的服务,那般就进行了基本的控制。

if __name__ == __main__ :
   itchat.auto_login(hotReload=True)
   itchat.run()

但是大伙儿不满意意足在此,我还希望可以对流程进行一些控制,对关键主要参数进行一些修改,因而:

@itchat.msg_register([itchat.content.TEXT])
def chat_trigger(msg):
   global lock, running, learning_rate, training_iters, batch_size, display_step
   if msg[ Text ] == u 一开始 :
       print( Starting )
       with lock:
           run_state = running
       if not run_state:
           try:
               threading.Thread(target=nn_train, args=(msg[ FromUserName ], (learning_rate, training_iters, batch_size, display_step))).start()
           except:
               msg.reply( Running )
   elif msg[ Text ] == u 停止 :
       print( Stopping )
       with lock:
           running = False
   elif msg[ Text ] == u 关键主要参数 :
       itchat.send( lr=%f, ti=%d, bs=%d, ds=%d %(learning_rate, training_iters, batch_size, display_step),msg[ FromUserName ])
   else:
       try:
           param = msg[ Text ].split()
           key, value = param
           print(key, value)
           if key == lr :
               learning_rate = float(value)
           elif key == ti :
               training_iters = int(value)
           elif key == bs :
               batch_size = int(value)
           elif key == ds :
               display_step = int(value)
       except:
           pass

依据这一,大伙儿可以在epoch中途停止(因为nn_train克林顿据检查running标识来确立不是是务必停住来),还能够在训练一开始前调整learning_rate等许多个关键主要参数。

的确是是非非常简易……

雷锋网经典著作权文章内容內容,没承受权禁止转截。详尽信息内容见。