What is the purpose of evaluating accuracy of a classifier function with Training data? In an supervised learning approach, the training data set is already labelled with correct values. So, what is the purpose of evaluating the accuracy of the classifier function after it gets trained with the training data set ? 
Wouldn't the accuracy be 100% since all the training data that is being fed will be correctly classified for it to learn from it.
example:
classifier = tf.estimator.LinearClassifier(feature_columns=feature_columns,n_classes=3,model_dir="/tmp/iris_model")
classifier.train(input_fn=input_fn(training_set),steps=1000)
accuracy_score = classifier.evaluate(input_fn=input_fn(test_set_, steps=100)["accuracy"]

 A: No, most certainly not!  In fact, if you got 100%, you should not trust your model, because you are most definitely overfitting, which is a bad thing.
Machine learning models learn from the data that you provide them, as you'd stated.  However, what you want for them to do is to learn so that they can fit data beyond the data you supplied.  This is typically done via some sort of assessment, like the accuracy that you mention.

Often, but not always, this is done by removing some of the data, then trying to fit that data and measure the accuracy.  There are different ways to do this, but 2 common ways are:


*

*Bootstrapping

*Cross-Validation
A: Well actually you are not deducing the values of y from the training set by using features X1, X2,..... Xn. You are actually training your model to get theta. Theta is the vector which is used to get predicted y. Hence, you don't get accuracy of 100% on your training set. This is because predicted y may be different from actual y.
However, it is advisable to use a separate training, cross-validation and test set for generating real time result of your model
A: A slightly different perspective.
As the other answers have noted, training error is not a useful measure of the predictive performance of a model, as it has very little to say about how your model will react to unseen data.  Simulating the model seeing new data is what cross validation is for.
On the other hand, training error satisfies a very useful constraint:

As the model complexity increases, training error always decreases.

Constraints are useful for debugging, as all experienced programmers know.  This means that whenever you have a modeling pipeline, which sometimes takes a significant amount of engineering work, it is useful to still observe the training error.  If the complexity constraint is not satisfied, i.e. if the training error goes up unexpectedly as model complexity increases, then it points to a bug or error in your engineering work.
