Facilitator Training Evaluation Form: Fill & Download for Free

The purpose of “Associate Consultant” at Infosys is to support consulting team in different phases of the project including problem definition, effort estimation, diagnosis, solution generation, design and deployment and participate in unit-level organization level initiatives with the object of providing high quality and value adding consulting solutions to customers within the guidelines, policies and norms of Infosys.And the responsibilities are:Problem Definition: Conduct secondary research that would help identify the problem areas IN ORDER TO assist in identifying the problem.Effort Estimation and Proposal Development: Conduct secondary research/ work with vendors to provide data points on effort estimation and proposal development IN ORDER TO ensure accurate effort estimation and deliver a proposal acceptable to the customer and to Infosys.Diagnostic /Discovery/As Is Assessment: Read the diagnostic/As-is-Assessment/Audit report to understand the recommendations IN ORDER TO use that as an input for the next phase of the project. Contribute to the diagnostic/As-is-assessment/Audit report.Solution Evaluation and Recommendation: Understand the solutions recommended and explore the alternatives based on research (literature survey, information available in public domains, info available in the repository, Vendor evaluation) build POCs and seek reviews IN ORDER TO assist in providing solution alternatives.Architecture/Design /Detailing of processes: Create requirements specifications from the business needs / to-be-processes defined and define detailed functional/process/infrastructure/security design based on requirements. Seek reviews, make changes as required and present to the supervisor IN ORDER TO create a to-be process/function design document. Create the architecture and design document TN ORDER TO complete the solution design (for SETL, design does not necessarily mean technical design).Development/ Configuration: Configure/build the application/ process solution in line with the design documents and also assist the team in requirement clarifications IN ORDER TO complete configuration and customization. Customize or tailor best practices, algorithms, solution capabilities in line with customer requirements.Validation (System): Document and publish test results/cases to supervisor IN ORDER to identify the design and development defects. Document and publish validation (or simulation) results for value of the IP from SETL.Deployment: Follow the steps for deployment as envisaged in the project plan, foresee possible cut-over/migration issues and plan for them proactively. S/he will resolve data migration issues, and resolve cut over user issues with speediness. S/he will coordinate with and assist other team members for deployment activities IN ORDER TO ensure a smooth go-live of new processes or product or system for the customer. (For SETL) Carry our evangelization, training, knowledge sharing, best practice demo - interventions to increase stickiness for SETL IP and consultants.Training & Change Management: Prepare training materials using available tools and the design application/ target system IN ORDER TO facilitate training for key users.Knowledge Transfer /System Appreciation: Study the existing systems and processes, document the system understanding, conduct reverse KT and seek sign-off IN ORDER TO commence the process of Support & Maintenance.Build & Maintain Process Repository: Review the existing repository in case of identification of new problems, or new solutions and then updates the information in the specified templates IN ORDER TO ensure reliability of current database.Issue Resolution (Incident/Problem Resolution): Understand the issue, diagnose the root cause of the issue, seek clarifications and then identify and shortlist solution alternatives IN ORDER TO resolve issues according to guidelines.Strategy and Business Planning: Perform secondary research for very specific items (like data analysis in verticals, functions) as instructed by the manager IN ORDER TO assist in strategy and business planning.Marketing and Branding: Create marketing material in the form of case studies, solution documentation, solution or POC demo scripts IN ORDER TO build collateral for marketing initiatives.Presales: Create and update the basic pieces of a proposal (right template, standard sections) and run OMATs with estimations from the technical and functional teams IN ORDER TO assist in presales activities to arrive at proposals agreeable to the clients.Product / Solution Development: Configure/assist in evaluating industry micro vertical/service/solution requirements on the product, document these in presentations and also create solution brochures IN ORDER To assist the team lead in solution development, product selection and documentation.Quality Management (limited relevance to IMS/EQS consultants): Work with the project manager to follow the methodology and capture relevant data in various phases of the project IN ORDER TO deliver a high quality solution to the customer. (For SETL) This responsibility is relevant only in those scenarios where working with project managers to capture required data in relevant project phases.Knowledge Management: Publish BOKs under the guidance of supervisor IN ORDER TO contribute to Knowledge Management

THESE ARE REFERENCES FROM ONLINE, SEPARATED BY LINESHYPERLINKS ARE IN BLUEIntroduction to Tensorflow EstimatorsTensorFlow Estimator is a high-level TensorFlow API that greatly simplifies machine learning programming. Estimators encapsulate training, evaluation, prediction, and exporting for your model.First contact with TensorFlow EstimatorWhat does TF estimator do?An Estimator is any class derived from tf.estimator.Estimator . TensorFlow provides a collection of pre-made Estimators (for example LinearRegressor) to implement common Machine Learning algorithms. These pre-implemented models allow quickly creating new models as need by customizing themFirst contact with TensorFlow EstimatorFirst contact with TensorFlow EstimatorThe high-level TensorFlow API that greatly simplifies ML programmingTensorFlow was originally created by researchers at Google as a single infrastructure for machine learning in both production and research. Later, an implementation of it was open sourced under the Apache 2.0 License in November 2015:Open-source machine learning library for numerical computation using data flow graphsUseful for research and productionAPIs for beginners and expertsThe development of deep learning (DL) networks requires rapid prototyping when testing new models. For this reason, several TensorFlow-based libraries have been built, which abstract many programming concepts and provide high-level building blocks. Nobody wants to waste time solving problems that have already been solved before. And chances are the ones who implemented the high-level API will have been experts in that low level problem and will have done a better job at solving it than you ever could.1. TensorFlow Estimators overviewTensorFlow Estimators is a High-level TensorFlow API that greatly simplifies machine learning programming introduced in a white paper in 2017. The design goals can be summarized asautomating repetitive and error-prone tasks, encapsulating best practices, and providing a ride from training to deployment.A schematic of Estimator can be seen as:Estimators InterfaceThe Estimators interface follows a train-evaluate-predict loop similar to scikit-learn. Estimator is the base class, pre-trained estimators (or pre-implemented models) are the sub-class.The user specifies the meat of their model in a model_fn, using conditionals to denote behaviour that differs between TRAIN, EVALUATE and PREDICT. They add also a set of input_fn to describe how to handle data, optionally specifying them separately for training, evaluation, and prediction.Custom Estimator mínimum layoutAt a high level, the code will need to create a custom Estimator (tf.estimator.Estimator) will be:A model function model_fn that is fed the features, labels and a few other parameters where your model code processes them and produces losses, metrics etc. The model function defines model, loss, optimizer, and metrics. This function has to return a tf.estimator.EstimatorSpecTwo input functions input_fnto feed the Estimators that returns features and labels for train and evalAn experiment object: to run the estimator in a configured stateFor further learning you can consult the research paper “Tensorflow Estimators : Managing Simplicity Vs Flexibility In High Level Machine Learning FrameWorks”.2. Building a CNN using TensorFlow estimatorsThis post will show how to encode with estimators the example of digits recognition, presented in a previous post encoded with Keras (I strongly recommend reading it previously):Convolutional Neural Networks (CNNs) are the current state-of-the-art model architecture for image classification tasks. CNNs apply a series of filters to the raw pixel data of an image to extract and learn higher-level features, which the model can then use for classification. Remember that CNNs contains three components:Convolutional layers, which apply a specified number of convolution filters to the image.Pooling layers, which downsample the image data extracted by the convolutional layers.Dense (fully connected) layers, which perform classification on the features extracted.3. Working EnvironmentColaboratoryIt is a Google research project created to help to disseminate Machine Learning education and research. It is a Jupyter notebook environment that requires no configuration and runs completely in the Cloud allowing the use of Keras, TensorFlow and PyTorch.By default, Colab notebooks run on CPU. You can switch your notebook to run with GPU. In order to obtain access to one GPU we need to choose the tab Runtime and then select “Change runtime type”. When a pop-up window appears select GPU. Ensure “Hardware accelerator” is set to GPU (the default is CPU).TensorboardTensorboard is a visualization tool that comes packaged with tensorflow. It is very useful to visualize and understand what’s going on under the hood. With tensorboard we can also track our loss metrics and other values to see how they are changing over training steps. We will use this tool for this purpose.For using tensorboard, we can save information with summary writers. Summaries are like condensed information about models. For example, if you want to capture summary stats for any metric, simply call tf.summary.scalarfunction with the metric name and value. Tensorboard creates visualizations out of this information.4. It is time to get your hands dirty!Open your Colaboratory and start with the following code:Load the librariesLoad the minimim necessary librariesimport osimport sysimport timeimport tensorflow as tfimport numpy as npParameter declarationAlthough it is not required by estimators, it is optional, we recommend have defined these parameters here to facilitate the tracking of the code._NUM_CLASSES = 10_MODEL_DIR = “model_name”_NUM_CHANNELS = 1_IMG_SIZE = 28_LEARNING_RATE = 0.05_NUM_EPOCHS = 20_BATCH_SIZE = 2048Model definitionAs you can see, the code is almost the same as in Keras:class Model(object):def __call__(self, inputs):net = tf.layers.conv2d(inputs, 32, [5, 5],activation=tf.nn.relu, name='conv1')net = tf.layers.max_pooling2d(net, [2, 2], 2,name='pool1')net = tf.layers.conv2d(net, 64, [5, 5],activation=tf.nn.relu, name='conv2')net = tf.layers.max_pooling2d(net, [2, 2], 2,name='pool2')net = tf.layers.flatten(net)logits = tf.layers.dense(net, _NUM_CLASSES,activation=None, name='fc1')return logitsModel function: model_fnNow its time to build the model defining the main function of the estimator. All we need to do is provide the TensorFlow Estimator API with a function that sets up the internal graph to build and run our model and returns back the training and loss ops, along with any hooks. The model function is of the form:def model_fn(features, labels, mode):...where:features: items returned from input_fnlabels: second item returned from input_fnmode: the mode the estimator is running in (basically training, validation or prediction).The mode parameter can take one of three values:tf.estimator.ModeKeys.TRAINtf.estimator.ModeKeys.EVALtf.estimator.ModeKeys.PREDICTThe estimator will call the function with the appropriate mode, and expects a tf.estimator.EstimatorSpec object in return (that will be used to build our custom estimator) that contains:the train/loss ops for trainingloss and metrics for evaluationpredictions for inference.We have defined the neural net model outside the function model_fn in order to have a more readable code although it is not required by estimators, it is optional.Generate PredictionsFor a given example, our predicted class is the element in the corresponding row of the logits tensor with the highest raw value. Remember that we can find the index of this element using the tf.argmax function. In our case will be:tf.argmax(input=logits, axis=1)The input argument specifies the tensor from which to extract maximum values. The axis argument specifies the axis of the input tensor along which to find the greatest value. Here, we consider the dimension 1, which corresponds to our predictions, because our logits tensor has shape [batch_size, 10).Once the evidence of belonging to each of the 10 classes has been calculated, these must be converted into probabilities whose sum of all their components add 1. For this, softmax uses the exponential value of the calculated evidence and then normalizes them so that the sum equates to one, forming a probability distribution. We can use:tf.nn.softmax(logits)For prediction, we will compile our predictions in a dict, and return an EstimatorSpec object as:predictions = {"predicted_logit": predicted_logit,"probabilities": probabilities}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode,predictions=predictions)Calculate lossWe need to define a loss function for both training and evaluation. In our example we will use cross entropy as the loss metric, in particular categorical crossentropy due data are categorical. The following code calculates cross entropy when the model runs in either TRAIN or EVAL mode:cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits, scope='loss')The parameter labels contain a list of prediction indices for the examples and logits contains the linear outputs of the last layer.TrainingAfter defining the loss let's configure our model to optimize this loss value during training. We'll use a learning rate of _LEARNING_RATE (defined earlier) and stochastic gradient descent as the optimization algorithm:optimizer =tf.train.GradientDescentOptimizer(learning_rate=_LEARNING_RATE)train_op =optimizer.minimize(cross_entropy, global_step=global_step)For a more in-depth you can see “Defining the training op for the model” in the “Creating Estimations in tf.estimator” TensorFlow tutorial.In order to visualize the training process with Tensorboard, we create a hook to print acc, loss and global step every 100 iterations with the following code:train_hook_list= []train_tensors_log = {'accuracy': accuracy[1],'loss': cross_entropy,'global_step': global_step}train_hook_list.append(tf.train.LoggingTensorHook(tensors=train_tensors_log, every_n_iter=100))Finally, we return the following EstimatorSpec in TRAIN mode:if mode == tf.estimator.ModeKeys.TRAIN:return tf.estimator.EstimatorSpec(mode=mode,loss=cross_entropy,train_op=train_op,training_hooks=train_hook_list)Evaluation metricsTo add accuracy metric in our model, we define eval_metric_ops dict in EVAL mode as follows:if mode == tf.estimator.ModeKeys.EVAL:return tf.estimator.EstimatorSpec(mode=mode,loss=cross_entropy,eval_metric_ops={'accuracy/accuracy': accuracy},evaluation_hooks=None)MonitoringSet Up a Logging HookSince CNNs can take a while to train, let’s set up some logging so we can track progress during training. We can use TensorFlow’s tf.train.SessionRunHook to create a tf.train.LoggingTensorHook that will log the probability values from the softmax layer of our CNN:train_hook_list= []train_tensors_log = {'accuracy': accuracy[1],'loss': cross_entropy,'global_step': global_step}train_hook_list.append(tf.train.LoggingTensorHook(tensors=train_tensors_log, every_n_iter=100))In this case, we create a hook to print accuracy, loss and global step every 100 iterations. Each key is a label of our choice that will be printed in the log output, and the corresponding label is the name of a Tensor in the TensorFlow graph.LoggingLogging is useful for debugging long-running training sessions or processes servicing inferences. TensorFlow supports the usual logging mechanism, with 5 levels in order of increasing severity as follows:DEBUGINFOWARNERRORFATALNote that the logs are generated from the graph execution, which occurs in the runtime. Setting a particular log level will show all messages from that level and all levels more severe. You can set the log level in the program by: tf.logging.set_verbosity(logging.info -&nbspThis website is for sale! -&nbspLogging Resources and Information.)Visualization with TensorboardWhen your program seems to run correctly but is not producing the expected result, you will need to debug at a higher level, and TensorBoard can be useful for this purpose. TensorBoard is a visualization tool for post-mortem analysis: you need to add calls in your program to generate data and write to an event file. For example, in order to obtain thetraining loss and training accuracy we will include the following code using tf.summary.scalar :with tf.name_scope('loss'):cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits, scope='loss')tf.summary.scalar('loss', cross_entropy)with tf.name_scope('accuracy'):accuracy = tf.metrics.accuracy(labels=labels, predictions=predicted_logit, name='acc')tf.summary.scalar('accuracy', accuracy[1])Refer to the module tf.summary for the complete API for working with TensorBoard data.model_fn: codeInclosed you will find the code commented so far, all together in the function model_fn:def model_fn(features, labels, mode):model = Model()global_step=tf.train.get_global_step()images = tf.reshape(features, [-1, _IMG_SIZE, _IMG_SIZE,_NUM_CHANNELS])logits = model(images)predicted_logit = tf.argmax(input=logits, axis=1,output_type=tf.int32)probabilities = tf.nn.softmax(logits)#PREDICTpredictions = {"predicted_logit": predicted_logit,"probabilities": probabilities}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode,predictions=predictions)with tf.name_scope('loss'):cross_entropy = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits, scope='loss')tf.summary.scalar('loss', cross_entropy)with tf.name_scope('accuracy'):accuracy = tf.metrics.accuracy(labels=labels, predictions=predicted_logit, name='acc')tf.summary.scalar('accuracy', accuracy[1])#EVALif mode == tf.estimator.ModeKeys.EVAL:return tf.estimator.EstimatorSpec(mode=mode,loss=cross_entropy,eval_metric_ops={'accuracy/accuracy': accuracy},evaluation_hooks=None)# Create a SGR optimizeroptimizer = tf.train.GradientDescentOptimizer(learning_rate=_LEARNING_RATE)train_op = optimizer.minimize(cross_entropy,global_step=global_step)# Create a hook to print acc, loss & global step every 100 iter.train_hook_list= []train_tensors_log = {'accuracy': accuracy[1],'loss': cross_entropy,'global_step': global_step}train_hook_list.append(tf.train.LoggingTensorHook(tensors=train_tensors_log, every_n_iter=100))if mode == tf.estimator.ModeKeys.TRAIN:return tf.estimator.EstimatorSpec(mode=mode,loss=cross_entropy,train_op=train_op,training_hooks=train_hook_list)As the reader can check, in all cases the model function return a tf.estimator.EstimatorSpec that will be used to build our custom estimator.4. Training and Evaluating the CNN MNIST ClassifierWe have coded our MNIST CNN model function; now we’re ready to train and evaluate it.Load Training and Test DataEven though the Dataset API allows us to build complex input pipelines we use estimators, in order to simplify this example and center it to estimators, we are going to obtain the MNIST data in a very simple way.We will load training and test data with the following code:mnist = tf.contrib.learn.datasets.load_dataset("mnist")train_data = mnist.train.images # Returns a np.arraytrain_labels = np.asarray(mnist.train.labels, dtype=np.int32)eval_data = mnist.test.images # Returns a np.arrayeval_labels = np.asarray(mnist.test.labels, dtype=np.int32)We store the training feature data and training labels as numpy arrays in train_data and train_labels, respectively. Similarly, we store the evaluation feature data and evaluation labels in eval_data and eval_labels, respectively.Input function to train the modelThe code to run the estimator expects to be provided with certain run-time parameters, s.a. batch size, number of epochs, as well as the input data. We will specify this information creating an input function as:train_input_fn = tf.estimator.inputs.numpy_input_fn(x=train_data,y=train_labels,batch_size=_BATCH_SIZE,num_epochs=1,shuffle=True)Now we’re ready to train our model, which we can do by creating train_input_fn and calling train():image_classifier.train(input_fn=train_input_fn)Input function to evaluate the modelOnce training is complete, we want to evaluate our model to determine its accuracy on the test dataset. We call the evaluate method, which evaluates the metrics we specified in eval_metric_ops argument in the model_fn. We create an input function for that:eval_input_fn = tf.estimator.inputs.numpy_input_fn(x=eval_data,y=eval_labels,num_epochs=1,shuffle=False)Now we are ready to eval our model:metrics = image_classifier.evaluate(input_fn=eval_input_fn)To create eval_input_fn for this simple example, we set num_epochs=1, so that the model evaluates the metrics over one epoch of data and returns the result. We also set shuffle=False to iterate through the data sequentially.Create the EstimatorNext, let’s create an Estimator (a TensorFlow class for performing high-level model training, evaluation, and inference) for our model, using model_fn:image_classifier = tf.estimator.Estimator(model_fn=model_fn, model_dir=_MODEL_DIR)Train and Evaluate the modelAfter creating the estimator, we can train and evaluate the model with this code:for _ in range(_NUM_EPOCHS):image_classifier.train(input_fn=train_input_fn)metrics = image_classifier.evaluate(input_fn=eval_input_fn)The full code of the classifierdef MNIST_classifier_estimator(_):# Load training and eval datamnist = tf.contrib.learn.datasets.load_dataset("mnist")train_data = mnist.train.images # Returns a np.arraytrain_labels = np.asarray(mnist.train.labels, dtype=np.int32)eval_data = mnist.test.images # Returns a np.arrayeval_labels = np.asarray(mnist.test.labels, dtype=np.int32)# Create a input function to traintrain_input_fn = tf.estimator.inputs.numpy_input_fn(x=train_data,y=train_labels,batch_size=_BATCH_SIZE,num_epochs=1,shuffle=True)# Create a input function to evaleval_input_fn = tf.estimator.inputs.numpy_input_fn(x=eval_data,y=eval_labels,batch_size=_BATCH_SIZE,num_epochs=1,shuffle=False)# Create a estimator with model_fnimage_classifier = tf.estimator.Estimator(model_fn=model_fn,model_dir=_MODEL_DIR)# Finally, train and evaluate the model after each epochfor _ in range(_NUM_EPOCHS):image_classifier.train(input_fn=train_input_fn)metrics = image_classifier.evaluate(input_fn=eval_input_fn)Running the estimatorWe have defined everything we need. Up until this point, no code has actually run.if __name__ == '__main__':tf.logging.set_verbosity(logging.info -&nbspThis website is for sale! -&nbspLogging Resources and Information.)tf.app.run(MNIST_classifier_estimator)The standard output of our execution will show the training metrics:INFO:tensorflow:loss = 2.3660345, step = 0INFO:tensorflow:accuracy = 0.079589844, global_step = 0, loss = 2.3660345INFO:tensorflow:global_step/sec: 66.4808INFO:tensorflow:loss = 0.698892, step = 100 (1.511 sec)INFO:tensorflow:accuracy = 0.45703125, global_step = 100, loss = 0.698892 (1.511 sec)INFO:tensorflow:global_step/sec: 68.7179INFO:tensorflow:loss = 0.48075008, step = 200 (1.456 sec)INFO:tensorflow:accuracy = 0.59375, global_step = 200, loss = 0.48075008 (1.455 sec)INFO:tensorflow:global_step/sec: 68.415INFO:tensorflow:loss = 0.4181886, step = 300 (1.461 sec)INFO:tensorflow:accuracy = 0.66589355, global_step = 300, loss = 0.4181886 (1.461 sec). . .Note: This program may finish with a “An exception has occurred, use %tb to see the full traceback.”. Don’t worry about it.5. Visualizing the model and the loss metrics using TensorboardWeb ServerTensorBoard runs as a web server, so you can access on the browser using the link provided later.Tensorboard also allows to display the internal graph of your neural network:For more details, and advanced visualization, please visit the TensorBoard page.However, as an important previous step for launching Tensorboard we need to tunnel the connection.Tunnel the connectionAfter your program has completed, the summaries can be viewed in Tensorboard by running tensorboard. You can run TensorBoard against this data:tensorboard --logdir=./tensorflow_logsIn order to run TensorBoard in Google Colab, we follow the “Quick guide to run TensorBoard in Google Colab” to use Ngrok in order to tunnel the connection with our local machine.Ngrok executable can be directly downloaded to your Colab notebook, run those two lines of code:!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip!unzip ngrok-stable-linux-amd64.zipNext, let’s fire up the TensorBoard in the background like this:get_ipython().system_raw('tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'.format(_MODEL_DIR))Then, we can run ngrok to tunnel TensorBoard port 6006 to the outside world. This command also runs in the background.get_ipython().system_raw('./ngrok http 6006 &')One last step, we get the public URL where we can access the TensorBoard web page with the following code:! curl -s http://localhost:4040/api/tunnels | python3 -c \"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"The previous code will output a URL like thisand you can click on.If we want to execute another experiment and visualize the result with TensorBoard, we need to (1) stop the actual TensorBoard process and launch another and (2) change the _MODEL_DIR parameter.In order to do that, if you want to rerun Tensorboard, you have to kill the process. Run top once, and look for Tensorboard’s PID, then killit as suggest the following code:! top -n 1! kill <PID_TENSORBOARD>AcknowledgmentMany thanks to Juan Luis Domínguez, a BSC-CNS engineer who wrote the first version of the code for this notebook and who discovered how to run TensorBoard in Google Colab. Thank you!Towards Data ScienceSharing concepts, ideas, and codes.Your journey starts here.Reducing your labeled data requirements (2–5x) for Deep Learning: Google Brain’s new “ContrastiveNeurIPS 2019: Entering the Golden Age of NLPData ScienceOpen-Sourcing Metaflow, a Human-Centric Framework for Data ScienceI’m a 37-Year-Old Mom & I Spent Seven Days Online as an 11-Year-Old Girl. Here’s What I Learned.)————————————————————————————————tf.estimator.Estimatortf.estimator.Estimator | TensorFlow Core r2.0Class EstimatorEstimator class to train and evaluate TensorFlow models.Inherits From: EstimatorUsed in the guide:Migrate your TensorFlow 1 code to TensorFlow 2Training checkpointsUsed in the tutorials:Multi-worker training with EstimatorThe Estimator object wraps a model which is specified by a model_fn, which, given inputs and a number of other parameters, returns the ops necessary to perform training, evaluation, or predictions.————————————————————————————————————————————————————————————————EstimatorsEstimators | TensorFlow CoreThis document introduces tf.estimator—a high-level TensorFlow API. Estimators encapsulate the following actions:trainingevaluationpredictionexport for servingYou may either use the pre-made Estimators we provide or write your own custom Estimators. All Estimators—whether pre-made or custom—are classes based on the tf.estimator.Estimator class.REFERENCESIntroduction to Tensorflow EstimatorsFirst contact with TensorFlow EstimatorEstimators | TensorFlow Coretf.estimator.Estimator | TensorFlow Core r2.0

Popular or not, the answer is yes. This assessment is based on two observations: (i) preeminent AIs are trained to emulate the best of human behaviors and (ii) AI interactions will open new opportunities for diplomatic activities including dramatically more efficient and effective multi-agent negotiation. This is not an exhaustive list but I’ll take some time to explain what I mean by each of these points.AI Behaves as The Best Human WouldBleeding edge artificial intelligence requires training before it can be trusted to perform a task. This isn’t any different than for us, as humans; for example, before letting a teen drive a car across the country, we might expect mom/dad to chaperone them through some slow circles in a parking lot and teach them how to avoid light poles and curbs. Mom/dad serve as the judge: evaluating the performance of the student driver. AI also needs a judge and, believe it or not, these are almost always humans. In order to train an AI to identify cats from pictures presented to it, we first have to know whether a set of images actually contain cats. We accomplish this by having lots of human eyeballs identify cats within a huge number of images!So what does all this have to do with having an AI as a government? An AI can only be as good at a task as its evaluator or judge. How do we judge a government? By voting! A good government will be really good at getting and keeping votes (at least so long as we evaluate them by this method). Likewise, an AI government’s primary task will be to gain and maintain popularity. It will employ whatever methods it is programmed to employ…if that is policy, then it will attempt to develop policy that preserves this popularity. If inputs are policy options and the outputs of such a robot were policy decisions meant to minimize changes in popularity, then this might be considered a relatively safe and mundane innovation (i.e. not terribly different than what effective politicians already do).What functions could an AI perform that could become dangerous? Communications comes immediately to mind. While we don’t have bots that do this really well yet, within the next couple of years robots will become fluid communicators and very persuasive. Combining communication with policy could be a runaway technology without having to stretch the imagination too much. But there remains some communication tasks that AI can and should facilitate!AI Diplomats and NegotiatorsOne of the most popular lines of rhetoric of the Trump campaign was that on matters of national security he was “not going to tell you” his plan[1]. This strategy was developed on the premise that showing our hand compromises its effectiveness. While this is not unimaginable, it is very difficult to reconcile with our representational governing style: we shouldn’t go to war without public consent. How are we to know if going to war is a good idea and provide consent if it compromises operational integrity? Enter AI intermediators. The public contracts an AI, trained to make a decision that the public can trust, this AI enters a secure room with the President and his advisers and provides a decision to them that represents binding consent of the public. This is a scenario which is just too appealing to not come true. This kind of technology could allow the public to have greater participation without relying on secret courts, biased or partisan politicians, etc. while also providing leaders with avenues for gauging public opinion without compromising operational integrity.While there are some details that would need to be hammered out to ensure the AI training is truly valid, this is a clear example of a task that an AI can perform which an ordinary human cannot. To be fair, this is not a new idea and can be extended to all complex negotiations. [2]Footnotes[1] Trump's plan on Russian provocations: 'I'm not going to tell you'[2] Deal or no deal? Training AI bots to negotiate