DOC: improve wording of basic tutorial (scikit-learn#10666)

Author: antquinonez

doc/tutorial/basic/tutorial.rst

@@ -21,7 +21,7 @@ more than a single number and, for instance, a multi-dimensional entry
 (aka `multivariate <https://en.wikipedia.org/wiki/Multivariate_random_variable>`_
 data), it is said to have several attributes or **features**.
 
-We can separate learning problems in a few large categories:
+Learning problems fall into a few categories:
 
  * `supervised learning <https://en.wikipedia.org/wiki/Supervised_learning>`_,
    in which the data comes with additional attributes that we want to predict
@@ -33,8 +33,8 @@ We can separate learning problems in a few large categories:
       <https://en.wikipedia.org/wiki/Classification_in_machine_learning>`_:
       samples belong to two or more classes and we
       want to learn from already labeled data how to predict the class
-      of unlabeled data. An example of classification problem would
-      be the handwritten digit recognition example, in which the aim is
+      of unlabeled data. An example of a classification problem would
+      be handwritten digit recognition, in which the aim is
       to assign each input vector to one of a finite number of discrete
       categories.  Another way to think of classification is as a discrete
       (as opposed to continuous) form of supervised learning where one has a
@@ -62,11 +62,12 @@ We can separate learning problems in a few large categories:
 .. topic:: Training set and testing set
 
     Machine learning is about learning some properties of a data set
-    and applying them to new data. This is why a common practice in
-    machine learning to evaluate an algorithm is to split the data
-    at hand into two sets, one that we call the **training set** on which
-    we learn data properties and one that we call the **testing set**
-    on which we test these properties.
+    and then testing those properties against another data set. A common
+    practice in machine learning is to evaluate an algorithm by splitting a data
+    set into two. We call one of those sets the **training set**, on which we
+    learn some properties; we call the other set the **testing set**, on which
+    we test the learned properties.
+
 
 .. _loading_example_dataset:
 
@@ -153,52 +154,53 @@ the classes to which unseen samples belong.
 In scikit-learn, an estimator for classification is a Python object that
 implements the methods ``fit(X, y)`` and ``predict(T)``.
 
-An example of an estimator is the class ``sklearn.svm.SVC`` that
+An example of an estimator is the class ``sklearn.svm.SVC``, which
 implements `support vector classification
 <https://en.wikipedia.org/wiki/Support_vector_machine>`_. The
-constructor of an estimator takes as arguments the parameters of the
-model, but for the time being, we will consider the estimator as a black
-box::
+estimator's constructor takes as arguments the model's parameters.
+
+For now, we will consider the estimator as a black box::
 
   >>> from sklearn import svm
   >>> clf = svm.SVC(gamma=0.001, C=100.)
 
 .. topic:: Choosing the parameters of the model
 
-  In this example we set the value of ``gamma`` manually. It is possible
-  to automatically find good values for the parameters by using tools
+  In this example, we set the value of ``gamma`` manually.
+  To find good values for these parameters, we can use tools
   such as :ref:`grid search <grid_search>` and :ref:`cross validation
   <cross_validation>`.
 
-We call our estimator instance ``clf``, as it is a classifier. It now must
-be fitted to the model, that is, it must *learn* from the model. This is
-done by passing our training set to the ``fit`` method. As a training
-set, let us use all the images of our dataset apart from the last
-one. We select this training set with the ``[:-1]`` Python syntax,
-which produces a new array that contains all but
-the last entry of ``digits.data``::
+The ``clf`` (for classifier) estimator instance is first
+fitted to the model; that is, it must *learn* from the model. This is
+done by passing our training set to the ``fit`` method. For the training
+set, we'll use all the images from our dataset, except for the last
+image, which we'll reserve for our predicting. We select the training set with
+the ``[:-1]`` Python syntax, which produces a new array that contains all but
+the last item from ``digits.data``::
 
   >>> clf.fit(digits.data[:-1], digits.target[:-1])  # doctest: +NORMALIZE_WHITESPACE
   SVC(C=100.0, cache_size=200, class_weight=None, coef0=0.0,
     decision_function_shape='ovr', degree=3, gamma=0.001, kernel='rbf',
     max_iter=-1, probability=False, random_state=None, shrinking=True,
     tol=0.001, verbose=False)
 
-Now you can predict new values, in particular, we can ask to the
-classifier what is the digit of our last image in the ``digits`` dataset,
-which we have not used to train the classifier::
+Now you can *predict* new values. In this case, you'll predict using the last
+image from ``digits.data``. By predicting, you'll determine the image from the 
+training set that best matches the last image.
+
 
   >>> clf.predict(digits.data[-1:])
   array([8])
 
-The corresponding image is the following:
+The corresponding image is:
 
 .. image:: /auto_examples/datasets/images/sphx_glr_plot_digits_last_image_001.png
     :target: ../../auto_examples/datasets/plot_digits_last_image.html
     :align: center
     :scale: 50
 
-As you can see, it is a challenging task: the images are of poor
+As you can see, it is a challenging task: after all, the images are of poor
 resolution. Do you agree with the classifier?
 
 A complete example of this classification problem is available as an
@@ -210,7 +212,7 @@ Model persistence
 -----------------
 
 It is possible to save a model in scikit-learn by using Python's built-in
-persistence model, namely `pickle <https://docs.python.org/2/library/pickle.html>`_::
+persistence model, `pickle <https://docs.python.org/2/library/pickle.html>`_::
 
   >>> from sklearn import svm
   >>> from sklearn import datasets
@@ -232,14 +234,14 @@ persistence model, namely `pickle <https://docs.python.org/2/library/pickle.html
   0
 
 In the specific case of scikit-learn, it may be more interesting to use
-joblib's replacement of pickle (``joblib.dump`` & ``joblib.load``),
-which is more efficient on big data, but can only pickle to the disk
+joblib's replacement for pickle (``joblib.dump`` & ``joblib.load``),
+which is more efficient on big data but it can only pickle to the disk
 and not to a string::
 
   >>> from sklearn.externals import joblib
   >>> joblib.dump(clf, 'filename.pkl') # doctest: +SKIP
 
-Later you can load back the pickled model (possibly in another Python process)
+Later, you can reload the pickled model (possibly in another Python process)
 with::
 
   >>> clf = joblib.load('filename.pkl') # doctest:+SKIP
@@ -283,7 +285,7 @@ Unless otherwise specified, input will be cast to ``float64``::
 In this example, ``X`` is ``float32``, which is cast to ``float64`` by
 ``fit_transform(X)``.
 
-Regression targets are cast to ``float64``, classification targets are
+Regression targets are cast to ``float64`` and classification targets are
 maintained::
 
     >>> from sklearn import datasets