replace "e.g." with "for example" (#1016)

* replace e.g. with for example

* feedback

* feedback

* undo release notes changes

Author: mairaw

README.md

@@ -8,7 +8,7 @@ ML.NET allows .NET developers to develop their own models and infuse custom ML i
 
 ML.NET was originally developed in Microsoft Research and evolved into a significant framework over the last decade and is used across many product groups in Microsoft like Windows, Bing, PowerPoint, Excel and more.
 
-With this first preview release, ML.NET enables ML tasks like classification (e.g. support text classification, sentiment analysis) and regression (e.g. price-prediction). 
+With this first preview release, ML.NET enables ML tasks like classification (for example, support text classification, sentiment analysis) and regression (for example, price-prediction).
 
 Along with these ML capabilities, this first release of ML.NET also brings the first draft of .NET APIs for training models, using models for predictions, as well as the core components of this framework such as learning algorithms, transforms, and ML data structures. 
 

docs/building/unix-instructions.md

@@ -28,7 +28,7 @@ The following components are needed:
 * curl
 * All the requirements necessary to run .NET Core 2.0 applications: libssl1.0.0 (1.0.2 for Debian 9) and libicu5x (libicu52 for ubuntu 14.x, libicu55 for ubuntu 16.x, and libicu57 for ubuntu 17.x). For more information on prerequisites in different linux distributions click [here](https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites?tabs=netcore2x).
 
-e.g. for Ubuntu 16.x:
+For example, for Ubuntu 16.x:
 
 ```sh
 sudo apt-get update

docs/code/IDataViewDesignPrinciples.md

@@ -415,7 +415,7 @@ the random number generator. Serving rows from disk in a random order is quite
 difficult to do efficiently (without seeking for each row). The binary .idv
 loader has some shuffling support, favoring performance over attempting to
 provide a uniform distribution over the permutation space. This level of
-support has been validated to be sufficient for machine learning goals (e.g.,
+support has been validated to be sufficient for machine learning goals (for example,
 in recent work on SA-SDCA algorithm). When the data is all in memory, as it is
 when cached, randomizing is trivial.
 

docs/code/IDataViewImplementation.md

@@ -327,7 +327,7 @@ ultimately limited by hardware and other runtime environment factors: the
 truth is, certain machines will, with identical programs with seemingly
 identical flows of execution result, *sometimes*, in subtly different answers
 where floating point values are concerned. Even on the same machine there are
-runtime considerations, e.g., when .NET's RyuJIT was introduced in VS2015, we
+runtime considerations, for example, when .NET's RyuJIT was introduced in VS2015, we
 had lots of test failures around our model consistency tests because the JIT
 was compiling the CLI just *slightly* differently. But, this sort of thing
 aside (which we can hardly help), we expect the models to be the same.
@@ -337,13 +337,13 @@ aside (which we can hardly help), we expect the models to be the same.
 When you create a loader you have the option of specifying not only *one* data
 input, but any number of data input files, including zero. But there's also a
 more general principle at work here with zero files: when deserializing a data
-loader from a data model with an `IMultiStreamSource` with `Count == 0` (e.g.,
+loader from a data model with an `IMultiStreamSource` with `Count == 0` (for example,
 as would be constructed with `new MultiFileSource(null)`), we have a protocol
 that *every* `IDataLoader` should work in that circumstance, and merely be a
 data view with no rows, but the same schema as it had when it was serialized.
 The purpose of this is that we often have circumstances where we need to
 understand the schema of the data (what columns were produced, what the
-feature names are, etc.) when all we have is the data model. (E.g., the
+feature names are, etc.) when all we have is the data model. (For example, the
 `savemodel` command, and other things.)
 
 # Getters Must Fail for Invalid Types
@@ -403,7 +403,7 @@ over an `IDataView`: while cursoring, you should almost certainly not throw
 exceptions.
 
 Imagine you have a `TextLoader`. You might expect that if you have a parse
-error, e.g., you have a column of floats, and one of the rows has a value
+error, for example, you have a column of floats, and one of the rows has a value
 like, `"hi!"` or something otherwise uninterpretable, you would throw. Yet,
 consider the implications of lazy evaluation. If that column were not
 selected, the cursoring would *succeed*, because it would not look at that
@@ -425,7 +425,7 @@ could throw the exception requires that a certain column be made active, then
 you should not throw. Of course, there are extreme circumstances: for example,
 one cannot help but throw on a cursoring if, say, there is some weird system
 event, and if one somehow detects in a subsequent iteration that something is
-fundamentally broken then you can throw: e.g., the binary loader will throw if
+fundamentally broken then you can throw: for example, the binary loader will throw if
 it detects the file it is reading is corrupted, even if that corruption may
 not have been obvious immediately.
 

docs/code/IDataViewTypeSystem.md

@@ -242,8 +242,8 @@ For example:
 
 * A column produced by a scorer may have several pieces of associated
   metadata, indicating the "scoring column group id" that it belongs to, what
-  kind of scorer produced the column (e.g., binary classification), and the
-  precise semantics of the column (e.g., predicted label, raw score,
+  kind of scorer produced the column (for example, binary classification), and the
+  precise semantics of the column (for example, predicted label, raw score,
   probability).
 
 The `ISchema` interface, including the metadata API, is fully specified in

docs/code/IdvFileFormat.md

@@ -21,7 +21,7 @@ to a particular within a block.)
 
 Before we discuss the format itself we will establish some conventions on how
 individual scalar values, strings, and other data is serialized. All basic
-pieces of data (e.g., a single number, or a single string) are encoded in ways
+pieces of data (for example, a single number, or a single string) are encoded in ways
 reflecting the semantics of the .NET `BinaryWriter` class, those semantics
 being:
 

docs/code/VBufferCareFeeding.md

@@ -44,7 +44,7 @@ inclusive and `Length` exclusive.
 Regarding the generic type parameter `T`, the only real assumption made about
 this type is that assignment (that is, using `=`) is sufficient to create an
 *independent* copy of that item. All representation types of the [primitive
-types](IDataViewTypeSystem.md#standard-column-types) have this property (e.g.,
+types](IDataViewTypeSystem.md#standard-column-types) have this property (for example,
 `DvText`, `DvInt4`, `Single`, `Double`, etc.), but for example, `VBuffer<>`
 itself does not have this property. So, no `VBuffer` of `VBuffer`s for you.
 
@@ -257,7 +257,7 @@ In terms of accessing anything in `Values` or `Indices`, remember, treat
 arrays.
 
 If you write code that results in two distinct `VBuffer`s sharing references
-to their internal arrays, (e.g., there are two `VBuffer`s `a` and `b`, with
+to their internal arrays, (for example, there are two `VBuffer`s `a` and `b`, with
 `a.Indices == b.Indices` with `a.Indices != null`, or `a.Values == b.Values`
 with `a.Values != null`) then you've almost certainly done something wrong.
 

docs/project-docs/contributing.md

@@ -16,7 +16,7 @@ Pull Requests
 -------------
 
 * **DO** submit all code changes via pull requests (PRs) rather than through a direct commit. PRs will be reviewed and potentially merged by the repo maintainers after a peer review that includes at least one maintainer.
-* **DO** give PRs short-but-descriptive names (e.g. "Improve code coverage for System.Console by 10%", not "Fix #1234")
+* **DO** give PRs short-but-descriptive names (for example, "Improve code coverage for System.Console by 10%", not "Fix #1234")
 * **DO** refer to any relevant issues, and include [keywords](https://help.github.com/articles/closing-issues-via-commit-messages/) that automatically close issues when the PR is merged.
 * **DO** tag any users that should know about and/or review the change.
 * **DO** ensure each commit successfully builds.  The entire PR must pass all tests in the Continuous Integration (CI) system before it'll be merged.

docs/specs/mvp.md

@@ -118,7 +118,7 @@ public partial class HousePricePrediction
   that decision.
 
 * The model should be immutable. We'll offer a conversion API to go from the
-  model to the building block for training, e.g. `ToPipeline()`.
+  model to the building block for training, for example, `ToPipeline()`.
 
 * The persisted `model.zip` has no notion of .NET types. It only has schema
   information. Strong typing requires the developer to specify the types when

src/Microsoft.ML.Analyzer/TypeIsSchemaShapeAnalyzer.cs

@@ -23,7 +23,7 @@ internal static class ShapeDiagnostic
             private const string Format = "Type{0} is neither a PipelineColumn nor a ValueTuple, nor a class of an allowed form.";
             internal const string Description =
                 "Within statically typed pipeline elements of ML.NET, the shape of the schema is determined by a 'shape' type. " +
-                "A valid 'shape' type is either an instance of one of the PipelineColumn subclasses (e.g., Scalar<bool> " +
+                "A valid 'shape' type is either an instance of one of the PipelineColumn subclasses (for example, Scalar<bool> " +
                 "or something like that), or a ValueTuple containing only valid 'shape' types, or a class whose only publicly " +
                 "accessible members are methods, a single constructor, and properties that are valid 'shape' types themselves, " +
                 "and that have either get and set accessors and the single constructor takes no parameters, or that has get only " +
@@ -44,7 +44,7 @@ internal static class ShapeParameterDiagnostic
             internal const string Description = ShapeDiagnostic.Description + " " +
                 "If using type parameters when interacting with the statically typed pipelines, the type parameter ought to be " +
                 "constrained in such a way that it, either by applying the [IsShape] attribute or by having type constraints to " +
-                "indicate that it is valid, e.g., constraining the type to descend from PipelineColumn.";
+                "indicate that it is valid, for example, constraining the type to descend from PipelineColumn.";
 
             internal static DiagnosticDescriptor Rule =
                 new DiagnosticDescriptor(Id, Title, Format, Category,

src/Microsoft.ML.Api/ComponentCreation.cs

@@ -317,7 +317,7 @@ public static IDataTransform CreateTransform(this IHostEnvironment env, string s
         /// <param name="data">The data to score.</param>
         /// <param name="predictor">The predictor to score.</param>
         /// <param name="trainSchema">The training data schema from which the scorer can optionally extract
-        /// additional information, e.g., label names. If this is <c>null</c>, no information will be
+        /// additional information, for example, label names. If this is <c>null</c>, no information will be
         /// extracted.</param>
         /// <returns>The scored data.</returns>
         public static IDataScorerTransform CreateScorer(this IHostEnvironment env, string settings,
@@ -348,7 +348,7 @@ public static IDataScorerTransform CreateScorer(this IHostEnvironment env, strin
         /// <param name="data">The data to score.</param>
         /// <param name="predictor">The predictor to score.</param>
         /// <param name="trainSchema">The training data schema from which the scorer can optionally extract
-        /// additional information, e.g., label names. If this is <c>null</c>, no information will be
+        /// additional information, for example, label names. If this is <c>null</c>, no information will be
         /// extracted.</param>
         /// <returns>The scored data.</returns>
         public static IDataScorerTransform CreateDefaultScorer(this IHostEnvironment env, RoleMappedData data,

src/Microsoft.ML.Core/Data/ICursor.cs

@@ -40,7 +40,7 @@ public interface ICounted
 
         /// <summary>
         /// A getter for a 128-bit ID value. It is common for objects to serve multiple <see cref="ICounted"/>
-        /// instances to iterate over what is supposed to be the same data, e.g., in a <see cref="IDataView"/>
+        /// instances to iterate over what is supposed to be the same data, for example, in a <see cref="IDataView"/>
         /// a cursor set will produce the same data as a serial cursor, just partitioned, and a shuffled cursor
         /// will produce the same data as a serial cursor or any other shuffled cursor, only shuffled. The ID
         /// exists for applications that need to reconcile which entry is actually which. Ideally this ID should

src/Microsoft.ML.Core/Data/ICursor.md

@@ -65,7 +65,7 @@ they not throw, return `true`, or have any other behavior.
 This treats on the requirements of a proper `GetIdGetter` implementation.
 
 It is common for objects to serve multiple `ICounted` instances to iterate
-over what is supposed to be the same data, e.g., in an `IDataView` a cursor
+over what is supposed to be the same data, for example, in an `IDataView` a cursor
 set will produce the same data as a serial cursor, just partitioned, and a
 shuffled cursor will produce the same data as a serial cursor or any other
 shuffled cursor, only shuffled. The ID exists for applications that need to
@@ -92,7 +92,7 @@ transformed, cached, saved, or whatever), that the IDs between the two
 different data views would have any discernable relationship.
 
 Since this ID is practically often derived from the IDs of some other
-`ICounted` (e.g., for a transform, the IDs of the output are usually derived
+`ICounted` (for example, for a transform, the IDs of the output are usually derived
 from the IDs of the input), it is not only necessary to claim that the ID
 generated here is probabilistically unique, but also describe a procedure or
 set of guidelines implementors of this method should attempt to follow, in
@@ -163,10 +163,10 @@ never arise that the same ID is hashed against the same data, and are
 introduced as if we expect them to be two separate IDs.
 
 Of course, with a malicious actor upstream, collisions are possible and can be
-engineered quite trivially (e.g., just by returning a constant ID for all
+engineered quite trivially (for example, just by returning a constant ID for all
 rows), but we're not supposing that the input `IDataView` is maliciously
 engineering hash states, or applying the operations above in any strange way
-to attempt to induce collisions. E.g., you could take, operation 1, define it
+to attempt to induce collisions. For example, you could take, operation 1, define it
 to be the enumeration of all `UInt128` values, then take operation 2 to select
 out specifically those that are hash states that will result in collisions.
 But I'm supposing this is not happening. If you are running an implementation

src/Microsoft.ML.Core/Data/IHostEnvironment.cs

@@ -219,7 +219,7 @@ public interface IChannel : IPipe<ChannelMessage>
     /// <summary>
     /// General utility extension methods for objects in the "host" universe, i.e.,
     /// <see cref="IHostEnvironment"/>, <see cref="IHost"/>, and <see cref="IChannel"/>
-    /// that do not belong in more specific areas, e.g., <see cref="Contracts"/> or
+    /// that do not belong in more specific areas, for example, <see cref="Contracts"/> or
     /// component creation.
     /// </summary>
     public static class HostExtensions

src/Microsoft.ML.Core/Data/IProgressChannel.cs

@@ -97,7 +97,7 @@ public sealed class ProgressHeader
         /// <param name="unitNames">The names of the progress units, listed from least granular to most granular.
         /// The idea is that the progress should be lexicographically increasing (like [0,0], [0,10], [1,0], [1,15], [2,5] etc.).
         /// As naming convention, <paramref name="unitNames"/> should be lower-cased and typically plural
-        /// (e.g. iterations, clusters, examples). </param>
+        /// (for example, iterations, clusters, examples). </param>
         public ProgressHeader(string[] metricNames, string[] unitNames)
         {
             Contracts.CheckValueOrNull(unitNames);
@@ -109,7 +109,7 @@ public ProgressHeader(string[] metricNames, string[] unitNames)
 
         /// <summary>
         /// A constructor for no metrics, just progress units. As naming convention, <paramref name="unitNames"/> should be lower-cased
-        /// and typically plural (e.g. iterations, clusters, examples).
+        /// and typically plural (for example, iterations, clusters, examples).
         /// </summary>
         public ProgressHeader(params string[] unitNames)
             : this(null, unitNames)

src/Microsoft.ML.Core/Data/ISchemaBindableMapper.cs

@@ -93,7 +93,7 @@ public interface IRowToRowMapper : ISchematized
         /// The optional <paramref name="disposer"/> should be invoked by any user of this row mapping, once it no
         /// longer needs the <see cref="IRow"/>. If no action is needed when the cursor is Disposed, the implementation
         /// should set <paramref name="disposer"/> to <c>null</c>, otherwise it should be set to a delegate to be
-        /// invoked by the code calling this object. (E.g., a wrapping cursor's <see cref="IDisposable.Dispose"/>
+        /// invoked by the code calling this object. (For example, a wrapping cursor's <see cref="IDisposable.Dispose"/>
         /// method. It's best for this action to be idempotent - calling it multiple times should be equivalent to
         /// calling it once.
         /// </summary>

src/Microsoft.ML.Core/Data/MetadataUtils.cs

@@ -42,13 +42,13 @@ public static class Kinds
             public const string ScoreColumnSetId = "ScoreColumnSetId";
 
             /// <summary>
-            /// Metadata kind that indicates the prediction kind as a string. E.g. "BinaryClassification".
+            /// Metadata kind that indicates the prediction kind as a string. For example, "BinaryClassification".
             /// The value is typically a ReadOnlyMemory&lt;char&gt;.
             /// </summary>
             public const string ScoreColumnKind = "ScoreColumnKind";
 
             /// <summary>
-            /// Metadata kind that indicates the value kind of the score column as a string. E.g. "Score", "PredictedLabel", "Probability". The value is typically a ReadOnlyMemory.
+            /// Metadata kind that indicates the value kind of the score column as a string. For example, "Score", "PredictedLabel", "Probability". The value is typically a ReadOnlyMemory.
             /// </summary>
             public const string ScoreValueKind = "ScoreValueKind";
 

src/Microsoft.ML.Core/Data/RoleMappedSchema.cs

@@ -79,7 +79,7 @@ public static ColumnInfo CreateFromIndex(ISchema schema, int index)
     /// individually configured). Also, by being a one-to-many mapping, it is a way for learners that can consume
     /// multiple features columns to consume that information.
     ///
-    /// This class has convenience fields for several common column roles (se.g., <see cref="Feature"/>, <see
+    /// This class has convenience fields for several common column roles (for example, <see cref="Feature"/>, <see
     /// cref="Label"/>), but can hold an arbitrary set of column infos. The convenience fields are non-null if and only
     /// if there is a unique column with the corresponding role. When there are no such columns or more than one such
     /// column, the field is <c>null</c>. The <see cref="Has"/>, <see cref="HasUnique"/>, and <see cref="HasMultiple"/>
@@ -110,7 +110,7 @@ public sealed class RoleMappedSchema
 
         /// <summary>
         /// Instances of this are the keys of a <see cref="RoleMappedSchema"/>. This class also holds some important
-        /// commonly used pre-defined instances available (e.g., <see cref="Label"/>, <see cref="Feature"/>) that should
+        /// commonly used pre-defined instances available (for example, <see cref="Label"/>, <see cref="Feature"/>) that should
         /// be used when possible for consistency reasons. However, practitioners should not be afraid to declare custom
         /// roles if approppriate for their task.
         /// </summary>