Those TensorFlow and black technology _ technology

The TensorFlow and the black Tech.

Google hosted the first TensorFlow developer summit in Mountain View, California, February 16, 2017 (Beijing time) 2 o'clock in the morning. Google site announced the world's leading deep learning open source Framework TensorFlow officially released the V1.0 version, and to ensure that Google's current release API interface to meet the production environment stability requirements. Objective

TensorFlow at the end of 2015 was a great concern, after more than a year of development, has become a machine learning, in-depth learning projects in one of the most popular framework. Since its release, TensorFlow has been refining and adding new functionality until a stable version of TensorFlow V1.0 was released at the conference. This is the first time Google TensorFlow developers and enthusiasts conference, we from the keynote speech, interesting applications, technology ecology, mobile and embedded applications to sum up the Conference's submit, I hope to help tensorflow developers. TensorFlow: A machine learning framework for the general public

TensorFlow in the past to obtain results mainly have the following: TensorFlow is used in Google many applications include: Gmail, Google Play recommendation, Search, Translate, map and so on; In medical terms, TensorFlow was used by scientists to build blindness to prevent diabetes based on the retina (also referred to as Stanford's PhD uses TensorFlow to predict skin cancer, related work on the nature cover); The field of painting uses TensorFlow to build a deep learning model to help people understand art better; use TensorFlow framework and High-tech equipment to build automated marine life testing systems to help scientists understand marine life; TensorFlow in Mobile client, there are a variety of mobile devices using TensorFlow to do translation, style and so on; TensorFlow on the mobile device CPU (Qualcomm 820), to achieve higher performance and lower power consumption; tensorflow Ecosystem combined with other open source projects can quickly build high-performance production environment; Tensorboard Embedded vector visualization can help phd/research workers to quickly carry out project research work.

Google's first generation of distributed machine Learning Framework Distbelief no longer meet Google's internal needs, Google's small partners in the Distbelief based on the redesign, the introduction of a variety of computing equipment support including CPU/GPU/TPU, And can be well run on the mobile side, such as Android devices, iOS, raspberry pie
And so on, support a variety of different languages (because of the various high-level APIs, training only supports python,inference support including C++,go,java, etc.), and includes great tools such as Tensorboard, Can effectively improve the efficiency of the in-depth study of research workers.

TensorFlow's growth in Google's internal project has also been rapid: there are applications in Google for several products such as: Gmail,google play recommendation, Search, Translate, map, etc. ; Nearly 100 project and paper use TensorFlow to do related work

TensorFlow has also gained a lot of results in the last 14 months of open source, including 475+ contributors,14000+ commits, and more than 5500 titles TensorFlow GitHub Project as well as on the stack overflow included 5000+ have been answered
The issue of an average of 80 + issue submissions per week.

In the past 1 years, TensorFlow from the beginning of the 0.5, almost 1.5 months of a version:

Release of TensorFlow 1.0

TensorFlow1.0 also released, although a lot of API has been changed, but also provides tf_upgrade.py to update your code. TensorFlow 1.0 on the distributed training Inception-v3 model, 64 GPU can achieve a 58X acceleration ratio, a more flexible high-level abstraction interface, and a more stable API. New High Level API

For the new abstract interface, TensorFlow relative to the other deeplearning framework to do better, layers can make it easy to build a model, Based on layer, including tf.learn inside the Scikit-learn style of the various estimator design and then will be integrated into the TensorFlow
Officially supported Keras, it allows small partners to configure the model structure, operation mode, model output and so on in a few lines, on top of which there are canned estimator, called model in box, such as Lr,kmeans.
Broad ML Support

There are some advanced machine learning algorithms implemented in TensorFlow, such as LR, SVM, Random Forest, There are many common machine learning algorithms implemented in Tf.learn that users can quickly use, and API styles are similar to Scikit-learn, and distributed support is mentioned in subsequent video. Xla:an Experimental TensorFlow Compiler

TensorFlow XLA can quickly turn tensorflow into a lower-level implementation (dependent on device), followed by talk detailing Xla.

Extensive cooperation Included in IBM ' s Powerai Support movidus Myriad 2 accelerator Qualcomm ' s Hexagon DSP (8 times times acceleration, here also invited the Qualcomm product owner to the platform) TensorFlow in Depth

TensorFlow has a very good advantage in both the production and the following diagram:

In model training, the performance of the 1 Machine 8 card is better than that in some standard benchmark or real data:

Of course, in the multi-machine distributed training, can achieve 64 GPU 58 times times the acceleration ratio:

TensorFlow is used by some of the top academic research projects:
-Neural Machine Translation
-Neural Architecture Search
-Show and tell

Of course tensorflow is also widely used in production:

such as mobile Google translate,gmail and so on, but also by many manufacturers at home and abroad to use as a model training tool.

These are Jeff Dean in keynote content, content a little more, and personally feel this group of Google's small partner ppt do a bit self-willed, but who call them the good, the next few talk more technical content, I believe you will be more interested. Interesting application cases of skin cancer image classification

First we say two data: 1. Medical institutions that count skin cancer at an early rate of cure are 98%;2. In 2020, 6.1 billion smartphones are expected worldwide.

What does this little brother do, he gets a batch of skin cancer data and then uses a pretrained inception-v3 to make a inference of the data,

And it's easy to build on the phone and do an app for early detection of skin cancer.

The final related results are published in Nature, and on the cover of Nature, which is a particularly successful technology through computer vision and deep learning, using cheap mobile devices that can effectively detect skin cancer and greatly reduce the cost of medical testing, believe that in the future
There will be more related technology coming up.
Using AI to predict diabetes and prevent blindness

This talk is also mentioned earlier to predict diabetes through retinal images and prevent blindness:
Predicting diabetes through retinal images is a difficult problem, and even professional doctors are hard to judge, but deep learning can help us:
By collecting the right amount of medical data and constructing a 26layers deep convolution network, we can let the network automatically learn the feature in these images to obtain higher classification accuracy, which is difficult to solve in human eyes.
The final evaluation of the model compared to the professional doctors, F-score 0.95, more than the number of professional doctors in the median of 0.91, which is too strong, I believe that will soon see in-depth study in the medical, especially the image analysis of the disease has a lot of amazing results.

Wide & Deep in Google play

This technique has a special fire for a period of time and is used to make recommendation related applications, first explaining the memorization and generalization:
The whole recommendation colleagues take into account the relevance of the product and some reasoning relationships, such as eagles fly, sparrows fly This kind of logic belongs to memorization, and said winged animals will fly this belongs to Genralization.

In specific application scenarios, such as Google Play's app recommendation:

Why to joint training, instead of directly with deep and wide to do ensemble it.
This gives an explanation here, because wide and deep will interact with each other, and the final precision will be high, and model will be relatively small:

The above mentioned wide & Deep Learning model only needs 10 lines of code to implement in TensorFlow (suddenly remembered the story of the 100-dollar drawing line):

Magenta: Music and art generation

This project is about the use of in-depth learning to do some art-related work, project address: Https://github.com/tensorflow/magenta
There are some very interesting things, such as the style, the formation of the artist style of music, using a depth learning model to simulate the human imagination of the arts, creating a deeplearning art style. Some of the development work done by the DeepMind team

After being acquired by Google, DeepMind also chose TensorFlow as the platform for in-depth study-related research and did a lot of interesting things: Data Center Cooling

This is one of several data centers that Google has around the world:
And then what did this group of Google's little partners do?
Google's small partners use intensive learning, yes. You're right. A technique used in Alphago to do automatic control of data center cooling equipment, and the effect is very significant:
Gorila

Gorial is an intensive learning framework under DeepMind, the Advanced API based on TensorFlow, is stable, and only needs to change a very small number of code to complete new experiments, support distributed training, very efficient,
And the trained model can be quickly deployed to the production environment through TensorFlow serving. Alphago

This believe not to say, we all know, the first in the go on the defeat of humans, and then upgraded version of the master 60 consecutive disk, the principle does not say, the network of many analytical articles, paste two pictures to pay tribute:
WaveNet: Speech Audio synthesis

Here DeepMind's little brother demonstrated wavenet some of the demo, specific can see here to understand.
Paste some effect comparison:

The combination of XLA, Keras and TensorFlow xla and TensorFlow

TensorFlow all aspects of the advantages are very prominent, in addition to the speed of this piece some deficiencies, if, tensorflow can do further optimization in speed, what will happen.

Yes, Google developers are aware of this problem, so with this xla, XLA Advantage: To improve the execution speed, the compilation of the child map will reduce the life cycle of the shorter op time, to at least tensorflow execution time, the integration of pipelined op to reduce the cost of memory; Reduce the cache of many intermediate results by analyzing and adjusting the memory requirements to reduce the reliance on customized OP, by providing automated fusion of the performance of the underlying OPS to reduce the memory footprint of the mobile device by delivering the performance of the custom OP, and using the AOT-compiled child graph to reduce tensorflow execution time , the ability to share Object/header file pair for other applications, the ability to reduce the number of levels of memory footprint on the mobile inference improve the portability of the program, without changing the majority of TensorFlow source code, Easily changed to accommodate new hardware devices,

XLA mainly includes two ways to use: JIT (Just in time) can automatically integrate some of the graphs in graph through XLA to reduce memory requirements to improve execution speed; AOT (ahead of time) can convert graph to executable source code in advance, Reduce the size of the resulting executable file,
Reduce the time consumption of the operation, a very obvious application scenario is the model on the mobile device inference optimization.

Because XLA principle involves compiler, this piece is not my good place, so here is passed, if interested small partner can pay attention to the next XLA docs and this tensorflow Dev Submit
On the talkxla:tensorflow of XLA, compiled!
Finally, paste some of the XLA performance:

Integration of Keras and TensorFlow

Keras is a deep learning framework that can be applied on many platforms, "an API specify for building deep learning models across many".
TensorFlow has been in the official TensorFlow support, 1.1 will be tf.keras in tf.contrib,1.2, and will support TensorFlow serving, is not very exciting.
The author of Keras the following in TensorFlow Dev submit:

So later Keras users can be faster in the framework of TensorFlow to make a corresponding model, can be more easily distributed training, using Google's cloud ML, for the super, and more important: tf-serving.
These feature now seem to have no support, but should be very soon, we can expect.
Here, Francois Chollet uses Keras to construct a VIDEO-QA model, which is described in the official document of Keras, which can be seen there, presumably a scene:

In such a scenario, it's hard to take advantage of native Python constructs, but with Keras, you just have to think about designing your model, and how you can accomplish similar functions without worrying about coding implementations, such as a simple model design for a similar problem:

A little more detail:

And how to achieve it in the Keras.

Video = Tf.keras.layers.Input (Shape= (None, 3))
CNN = tf.keras.applications.InceptionV3 (weights= ' Imagenet ', Include_top=false, pool= ' avg)

cnn.trainable = False
encoded_frames = Tf.keras.layers.TimeDistributed (CNN) (video)
Encoded_vid = Tf.layers.LSTM (256) (encode_frames)

question = Tf.keras.layers.Input (shape=), Dtype= ' int32 ')
x = tf.keras.layers.Embedding (10000, 256, mask_zero=true) ( Question)
encoded_q = Tf.keras.layers.LSTM (128) (x)

x = Tf.keras.layers.concat ([Encoded_vid, Encoded_q])
x = tf.keras.layers.Dense (128, Activation=tf.nn.relu) (x)
outputs = Tf.keras.layers.Dense (1000) (x)

Model = Tf.keras.models.Mode ([video, question], outputs)
model.compile (OPTIMIZER=TF. Adamoptimizer (), loss=tf.softmax_crossentropy_with_logits)

Here the code is not running on the current version of TensorFlow, and if you want to know the simplicity of building the above model on the Keras, you can look at the Keras documentation (https://keras.io/getting-started/functional-api-guide/).
Keras is well known for its convenience in constructing depth models, and is worth looking forward to after Keras updates in TensorFlow:

TensorFlow high-level apis:models in a Box

TensorFlow is doing well with flexibility, scalability, and maintainability, but now it's not enough in the Advanced API, modular algorithm, but Google brain's engineers introduced some of the high-level APIs on this talk. Layers: Encapsulates some layers of operation, simplifying the original TensorFlow source code, such as a new variable to do weight, etc. estimator or Keras: encapsulates some higher-level operations including, train and evaluate operations, Users can quickly build training and evaluation processes with a few lines of code canned estimators: more advanced API, so-called models in a box

Constructing the depth network shown in the left image requires only seven lines of code in the right of the figure
Similarly, building training, evaluation, and forecasting can also be done quickly through API calls:

Finally, model in a Box

Area = Real_valued_column ("Square_foot")
rooms = Real_valued_column ("num_rooms")
Zip_Code = Sparse_column_ With_integerized_feature ("Zip_Code", 100000)

regressor = Linearregressor (Feature_columns=[area, Room, Zip_Code] )
Classifier.fit (TRAIN_INPUT_FN)
classifier.evaluate (EVAL_INPUT_FN)

Some other technologies as well as eco-ML Toolkit

TensorFlow may have been the first to be known, because everyone thinks he is a framework for deep learning, in fact, there are many machine learning algorithms in TensorFlow now integration:

and the development of algorithm API is modeled after Scikit-learn style, there is python under the machine to learn the small partner, can quickly adapt.
Here it is worth proposing, interesting tensorflow support for machine learning and deep learning models, which can be especially easy to combine with traditional machine learning methods and deep learning models:

Distributed TensorFlow

TensorFlow in distributed performance, mentioned earlier, in the 1.0 version has a great upgrade to achieve 64 GPU 58 times times the acceleration, here first the basic introduction of data parallelism and model parallelism: Data parallel each worker has a complete model, part of the data, The update of the parameter is passed to params Server; Model parallel to each worker on a part of the network model;

How to write distributed code in TensorFlow, here I do not say, very simply configure, here I talk about, probably most of my little friends like me before not quite understand some of the eggs
Some of the techniques of distributed training in TensorFlow, and the experience of distributed train should be appreciated for these black technologies:
-Round-robin variables
-Load balancing and partitioning

What does it say? Params server when saving the parameters of the model, the default is to save a variable each PS, and then next to the next PS to save, but there will be many problems, perhaps this variable is very small, but the other is very large, so you will find PS and work
Bandwidth between the Occupy a lot of gaps, how to solve it. Take a look at the following pictures

Said Han aside, why I am particularly excited when I see here, the author in the development of a distributed training platform within the team encountered this problem, we tested the Alexnet model, found that the bandwidth consumption of multiple PS is very different, due to the alexnet model with the last three
There are too many parameters in the full connection, resulting in unbalanced Ps.

Above said the next distributed TensorFlow I particularly excited things, after talk is relatively simple, if the TensorFlow do distributed job, the document has, very simple, here does not mention
No, we have to say tensorflow. A support for disaster tolerance:
The following figure is the case of several distributed machine hangs:
That's a lot of trouble, but it's all right, but it's okay to make a quick recovery of these in tensorflow, just change one line of code:

To put a model into a production environment

How to quickly deploy the training model in the production environment to provide available services, TensorFlow serving is focused on this piece, I would like to briefly introduce the following:

Providing the training model with the services available in the production environment usually has the following requirements: long-term stability services, low-delay support for multiple model services support for the same model multiple versions to ensure a small amount of computation time to ensure that some real-time requirements mini-batching support to improve efficiency

TensorFlow serving is designed to address these needs, and TensorFlow is based on GRPC and supports multiple languages. TensorFlow Ecological

This section is about using the TensorFlow ecosystem to make better use of tensorflow, such as Spark, Hadoop, etc., that combine some processes. Data Preparation work

The supported data-reading methods, from fast to slow, are:
1.TF. Example, TF. Sequenceexample object;
2. The original Read Csv,json op
3. Feed data directly from Python (simplest)

How to support Tfrecords (beam native support) in other such as Hadoop, Spark, see TensorFlow Ecosystem cluster Management

TensorFlow supports the following multiple frameworks:
The Distributed storage container support model exports the standard save format of the Savedmodel:1,tensorflow model; 2, including the following necessary assets, such as vocabularies (not too can turn, what meaning); Graphdef: Typically, the model of a mobile device is saved compared to the universal mobile end and the embedded application mobile and Embedded TensorFlow

Pete Warden describes how to use TensorFlow for mobile devices such as Android, iOS devices, and raspberry pie, and it may be useful for small partners who are interested in developing mobile device programs. Hands on Tensorboard

This talk mainly introduces some of the applications of Tensorboard, many of which have not been tried before, and have benefited greatly after listening to the speaker's description.

# Define A simple convolutional layer def conv_layer (input, channels_in, channels_out): w = tf. Variable (Tf.zeros ([5, 5, channels_in, Channels_out])) b = tf. Variable (Tf.zeros ([Channels_out])) conv = tf.nn.conv2d (input, W, strides=[1, 1, 1, 1], padding= "SAME") act = tf. Nn.relu (CONV + b) Return Act # and a fully connected layer def fc_layer (input, channels_in, channels_out): w = Tf. Variable (Tf.zeros ([channels_in, Channels_out])) b = tf. Variable (Tf.zeros ([channels_out]) act = tf.nn.relu (Tf.matmul (Input, W) + b) Return Act # Setup placeholders, a D reshape the data x = Tf.placeholder (Tf.float32, Shape=[none, 784]) y = Tf.placeholder (Tf.float32, Shape=[none, ten)) x _image = Tf.reshape (x, [-1, MB, 1]) # Create the network Conv1 = Conv_layer (x_image, 1,) pool1 = Tf.nn.max_pool (c ONV1, Ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding= "SAME") Conv2 = Conv_layer (pooled, MB) pool2 = Tf.nn.max_pool ( Conv2, Ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding= "SAME") flattened = Tf.reshape (Pool2, [-1, 7 * 7 *]) FC1 = Fc_layer (flattened, 7 * 7 *, 1024) L Ogits = Fc_layer (FC1, 1024,) # Compute cross entropy as our loss function Cross_entropy = Tf.reduce_mean (Tf.nn.softma X_cross_entropy_with_logits (Logits=logits, labels=y)) # Use a Adamoptimizer to train the network Train_step = Tf.train.A Damoptimizer (1e-4). Minimize (cross_entropy) # COMPUTE accuracy correct_prediction = tf.equal (Tf.argmax (logits, 1), Tf.argmax (y, 1)) accuracy = Tf.reduce_mean (Tf.cast (correct_prediction, Tf.float32)) # Initialize all variables SESS.R Un (Tf.global_variables_initializer ()) # Train for steps to I in range: Batch = Mnist.train.next_batch (100) # Occasionally accuracy if I% = 0: [Train_accuracy] = Sess.run ([accuracy], feed_dict={x:batch[0], y:batch[1] }) Print ("Step%d, training accuracy%g"% (I, train_accuracy)) # Run The Training step sess.run (Train_step, Feed_di Ct={x:batch[0], Y_true:baTCH[1]}) 

Many small partners have written similar code, constructed the network, then set the training mode, and finally output some basic results information, as follows:

Step 0, training accuracy 10%, 
training accuracy 12% Step 
1500, training accuracy 9% step 
, train ing accuracy 13%

TensorFlow gives you not only these, there is a special great tool Tensorboard can visualize the training process of information, can make people intuitive feeling, of course, need some simple configuration:

Write graph

writer = Tf.summary.FileWriter ("/TMP/MNIST_DEMO/1") 
writer.add_graph (sess.graph)

Although this can visualize graph, but it is very messy, we can add name,scope to some node to make the picture better:

def conv_layer (input, channels_in, Channels_out, name= "conv"): With Tf.name_scope (name): w = tf. Variable (Tf.zeros ([5, 5, channels_in, Channels_out]), name= "W") b = tf. 
        Variable (Tf.zeros ([Channels_out]), name= "B") conv = tf.nn.conv2d (input, W, strides=[1, 1, 1, 1], padding= "SAME") act = tf.nn.relu (conv + b) return Tf.nn.max_pool (Act, Ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding= "SAME") def fc_layer (input, channels_in, Channels_out, name= "FC"): With Tf.name_scope (name): w = tf. Variable (Tf.zeros ([channels_in, Channels_out]), name= "W") b = tf.  Variable (Tf.zeros ([Channels_out]), name= "B") return Tf.nn.relu (Tf.matmul (Input, W) + B) # Setup placeholders, and 
Reshape the data x = Tf.placeholder (Tf.float32, Shape=[none, 784], name= "x") X_image = Tf.reshape (x, [-1, 28, 28, 1]) y = Tf.placeholder (Tf.float32, Shape=[none, ten], name= "labels") Conv1 = Conv_layer (x_image, 1, "conv1") Conv2 = conv_l Ayer (CONV1, Conv2, flattened = Tf.reshape (Conv2, [-1, 7 * 7 *)] FC1 = Fc_layer (flattened, 7 * 7 *, 1024, "FC1") log its = Fc_layer (FC1, 1024, the "FC2") with Tf.name_scope ("Xent"): Xent = Tf.reduce_mean (tf.nn.softmax_cross_entropy_w Ith_logits (Logits=logits, labels=y)) with Tf.name_scope ("Train"): Train_step = Tf.train.AdamOptimizer (1e-4). Minimize (xent) with tf.name_scope ("accuracy"): Correct_prediction = Tf.equal (Tf.argmax (logits, 1), Tf.argmax (Y, 1)) Accu 
Racy = Tf.reduce_mean (Tf.cast (correct_prediction, tf.float32)) writer = Tf.summary.FileWriter ("/TMP/MNIST_DEMO/2") Writer.add_graph (Sess.graph)

Through the TensorFlow API, more data records are collected and displayed in Tensorboard:

Tf.summary.scalar (' cross_entropy ', xent)
tf.summary.scalar (' accuracy ', accuracy)
tf.summary.image (' Input ', x_image, 3)

Modify the Conv code to add weight,bias,act to the histogram:

def conv_layer (input, channels_in, Channels_out, name= "conv"): With 
    tf.name_scope (name): 
    w = tf. Variable (Tf.zeros ([5, 5, channels_in, Channels_out]), name= "W") 
    B = tf. Variable (Tf.zeros ([Channels_out]), name= "B") 
    conv = tf.nn.conv2d (input, W, strides=[1, 1, 1, 1], padding= "SAME") 
    act = tf.nn.relu (conv + b) 
    Tf.summary.histogram ("weights", W) 
    Tf.summary.histogram ("biases", b) 
    Tf.summary.histogram ("activations", ACT) return 
    Tf.nn.max_pool (Act, Ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], Paddin g= "SAME")

Configuration writes data from the training process to:

Merged_summary = Tf.summary.merge_all () 
writer = Tf.summary.FileWriter ("/TMP/MNIST_DEMO/3") 
writer.add_ Graph (sess.graph) for

I in Range (2001): 
    batch = Mnist.train.next_batch (m) 
    if I% 5 = 0: 
        s = Sess.run (Me Rged_summary, Feed_dict={x:batch[0], y:batch[1]} 
        writer.add_summary (S, i) 
        Sess.run (Train_step, feed_dict= {x:batch[0], y:batch[1]}

Hyperparameter Search

This tensorboard talk give me the biggest harvest is to do with Tensorboard Hyperparamter Search is so convenient, this talk the main demonstration of two aspects of the parameters: different learning rate

Different network structure Try a few learning rates

For learning_rate in [1E-3, 1E-4, 1E-5]:
# Try a model with fewer layers to use_two_fc in [True, False]:
For Use_two_conv in [True, False]:
# construct a hyperparameter string for each one (example: "lr_1e-3,fc=2,conv=2)
Hparam_str = make_hparam_string (Learning_rate, Use_two_fc, Use_two_conv)
writer = Tf.summary.FileWriter ("/tmp/mnist_tutorial/" + hparam_str)
# actually run with the new settings
Mnist (Learning_rate, Use_two_fully_connected_layers, Use_two_conv_layers, writer)

Tensorboard--logdir/tmp/mnist_tutorial

Embedding Visualizer

embedding = tf.
Variable (Tf.zeros ([10000, embedding_size]), name= "test_embedding") Assignment = Embedding.assign (embedding_input) 
Config = tf.contrib.tensorboard.plugins.projector.ProjectorConfig () Embedding_config = Config.embeddings.add () Embedding_config.tensor_name = Embedding.name Embedding_config.sprite.image_path = Os.path.join (Log_dir, ' sprite.png 
') # Specify the width and height of a single thumbnail. Embedding_config.sprite.single_image_dim.extend ([a]) tf.contrib.tensorboard.plugins.projector.visualize_ Embeddings (writer, config) for I in Range (2001): Batch = Mnist.train.next_batch (m) if I% 5 = 0: [t 
    Rain_accuracy, S] = Sess.run ([accuracy, Summ], feed_dict={x:batch[0], y:batch[1]}) writer.add_summary (s, i) If I% = = 0:sess.run (Assignment, Feed_dict={x:mnist.test.images, y_true:mnist.test.labels}) Sav Er.save (Sess, Os.path.join (Log_dir, "model.ckpt"), i) Sess.run (Train_step, feed_dict={x:batch[0], y_TRUE:BATCH[1]}) 

Future for Tensorboard

The future tensorboard will do some promotion in the following three aspects: integration of TensorFlow on Tensorboard the support of the enterprise-class Tensorboard

As usual, it is easy to see from above that TensorFlow has done a lot of interesting work in the past year, whether in reasearch or production, including a variety of interesting tools, One of the most harvested is the use of TensorFlow to do the regulation of the Super parameter, and new support for Keras, distributed optimization methods for various model variables, distributed disaster-tolerant, XLA support Yes, the model is faster, so it's not wasteful to spend time watching these speeches, but because of the limited personal knowledge, If there is a mistake or not thoughtful
Place, please note that you are kindly excused.

Original website: https://www.zybuluo.com/tinadu/note/672735