Improve error reporting uniformity through usage of SchemaMismatch contracts helpers.

TomFinley · TomFinley · commit ac287d87b770 · 2018-12-19T13:05:26.000-08:00
diff --git a/src/Microsoft.ML.Data/Evaluators/BinaryClassifierEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/BinaryClassifierEvaluator.cs
@@ -129,11 +129,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var host = Host.SchemaSensitive();
             var t = score.Type;
             if (t.IsVector || t.ItemType != NumberType.Float)
-                throw host.SchemaSensitive().Except("Score column '{0}' has type '{1}' but must be R4", score, t);
+                throw host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "R4", t.ToString());
             host.Check(schema.Label.HasValue, "Could not find the label column");
             t = schema.Label.Value.Type;
             if (t != NumberType.R4 && t != NumberType.R8 && t != BoolType.Instance && t.KeyCount != 2)
-                throw host.SchemaSensitive().Except("Label column '{0}' has type '{1}' but must be R4, R8, BL or a 2-value key", schema.Label.Value.Name, t);
+                throw host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "R4, R8, BL or a 2-value key", t.ToString());
         }
 
         private protected override void CheckCustomColumnTypesCore(RoleMappedSchema schema)
@@ -142,14 +142,14 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche
             var host = Host.SchemaSensitive();
             if (prob != null)
             {
-                host.Check(prob.Count == 1, "Cannot have multiple probability columns");
+                host.CheckParam(prob.Count == 1, nameof(schema), "Cannot have multiple probability columns");
                 var probType = prob[0].Type;
                 if (probType != NumberType.Float)
-                    throw host.SchemaSensitive().Except("Probability column '{0}' has type '{1}' but must be R4", prob[0].Name, probType);
+                    throw host.ExceptSchemaMismatch(nameof(schema), "probability", prob[0].Name, "R4", probType.ToString());
             }
             else if (!_useRaw)
             {
-                throw host.Except(
+                throw host.ExceptParam(nameof(schema),
                     "Cannot compute the predicted label from the probability column because it does not exist");
             }
         }
diff --git a/src/Microsoft.ML.Data/Evaluators/ClusteringEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/ClusteringEvaluator.cs
@@ -99,15 +99,14 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             ColumnType type = schema.Label?.Type;
             if (type != null && type != NumberType.Float && !(type is KeyType keyType && keyType.Count > 0))
             {
-                throw Host.Except("Clustering evaluator: label column '{0}' type must be {1} or Key of known cardinality." +
-                    " Provide a correct label column, or none: it is optional.",
-                    schema.Label.Value.Name, NumberType.Float);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name,
+                    "R4 or key of known cardinality", type.ToString());
             }
 
             var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
             type = score.Type;
             if (!type.IsKnownSizeVector || type.ItemType != NumberType.Float)
-                throw Host.Except("Scores column '{0}' type must be a float vector of known size", score.Name);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "R4 vector of known size", type.ToString());
         }
 
         private protected override void CheckCustomColumnTypesCore(RoleMappedSchema schema)
@@ -118,8 +117,8 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche
                 var t = schema.Feature.Value.Type;
                 if (!t.IsKnownSizeVector || t.ItemType != NumberType.Float)
                 {
-                    throw Host.Except("Features column '{0}' type must be {1} vector of known-size",
-                        schema.Feature.Value.Name, NumberType.Float);
+                    throw Host.ExceptSchemaMismatch(nameof(schema), "features", schema.Feature.Value.Name,
+                        "R4 vector of known size", t.ToString());
                 }
             }
         }
diff --git a/src/Microsoft.ML.Data/Evaluators/MultiClassClassifierEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/MultiClassClassifierEvaluator.cs
@@ -77,11 +77,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
             var t = score.Type;
             if (t.VectorSize < 2 || t.ItemType != NumberType.Float)
-                throw Host.Except("Score column '{0}' has type {1} but must be a vector of two or more items of type R4", score.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "vector of two or more items of type R4", t.ToString());
             Host.CheckParam(schema.Label.HasValue, nameof(schema), "Could not find the label column");
             t = schema.Label.Value.Type;
             if (t != NumberType.Float && t.KeyCount <= 0)
-                throw Host.Except("Label column '{0}' has type {1} but must be a float or a known-cardinality key", schema.Label.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "float or a known-cardinality key", t.ToString());
         }
 
         private protected override Aggregator GetAggregatorCore(RoleMappedSchema schema, string stratName)
diff --git a/src/Microsoft.ML.Data/Evaluators/MultiOutputRegressionEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/MultiOutputRegressionEvaluator.cs
@@ -60,11 +60,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
             var t = score.Type;
             if (t.VectorSize == 0 || t.ItemType != NumberType.Float)
-                throw Host.Except("Score column '{0}' has type '{1}' but must be a known length vector of type R4", score.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "known size vector of R4", t.ToString());
             Host.Check(schema.Label.HasValue, "Could not find the label column");
             t = schema.Label.Value.Type;
             if (!t.IsKnownSizeVector || (t.ItemType != NumberType.R4 && t.ItemType != NumberType.R8))
-                throw Host.Except("Label column '{0}' has type '{1}' but must be a known-size vector of R4 or R8", schema.Label.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "known size vector of R4 or R8", t.ToString());
         }
 
         private protected override Aggregator GetAggregatorCore(RoleMappedSchema schema, string stratName)
diff --git a/src/Microsoft.ML.Data/Evaluators/QuantileRegressionEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/QuantileRegressionEvaluator.cs
@@ -58,14 +58,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
             var t = score.Type;
             if (t.VectorSize == 0 || (t.ItemType != NumberType.R4 && t.ItemType != NumberType.R8))
-            {
-                throw Host.Except(
-                    "Score column '{0}' has type '{1}' but must be a known length vector of type R4 or R8", score.Name, t);
-            }
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "vector of type R4 or R8", t.ToString());
             Host.CheckParam(schema.Label.HasValue, nameof(schema), "Must contain a label column");
             t = schema.Label.Value.Type;
             if (t != NumberType.R4)
-                throw Host.Except("Label column '{0}' has type '{1}' but must be R4", schema.Label.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", schema.Label.Value.Name, "R4", t.ToString());
         }
 
         private protected override Aggregator GetAggregatorCore(RoleMappedSchema schema, string stratName)
diff --git a/src/Microsoft.ML.Data/Evaluators/RankerEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/RankerEvaluator.cs
@@ -89,14 +89,14 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var t = schema.Label.Value.Type;
             if (t != NumberType.Float && !(t is KeyType))
             {
-                throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.LabelColumn), "Label column '{0}' has type '{1}' but must be R4 or a key",
-                    schema.Label.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.LabelColumn),
+                    "label", schema.Label.Value.Name, "R4 or a key", t.ToString());
             }
-            var scoreInfo = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
-            if (scoreInfo.Type != NumberType.Float)
+            var scoreCol = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
+            if (scoreCol.Type != NumberType.Float)
             {
-                throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.ScoreColumn), "Score column '{0}' has type '{1}' but must be R4",
-                    scoreInfo.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.ScoreColumn),
+                    "score", scoreCol.Name, "R4", t.ToString());
             }
         }
 
@@ -105,9 +105,8 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche
             var t = schema.Group.Value.Type;
             if (!(t is KeyType))
             {
-                throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.GroupIdColumn),
-                    "Group column '{0}' has type '{1}' but must be a key",
-                    schema.Group.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.GroupIdColumn),
+                    "group", schema.Group.Value.Name, "key", t.ToString());
             }
         }
 
diff --git a/src/Microsoft.ML.Data/Evaluators/RegressionEvaluator.cs b/src/Microsoft.ML.Data/Evaluators/RegressionEvaluator.cs
@@ -57,11 +57,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)
             var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);
             var t = score.Type;
             if (t != NumberType.Float)
-                throw Host.Except("Score column '{0}' has type '{1}' but must be R4", score, t);
-            Host.Check(schema.Label.HasValue, "Could not find the label column");
+                throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "R4", t.ToString());
+            Host.CheckParam(schema.Label.HasValue, nameof(schema), "Could not find the label column");
             t = schema.Label.Value.Type;
             if (t != NumberType.R4)
-                throw Host.Except("Label column '{0}' has type '{1}' but must be R4", schema.Label.Value.Name, t);
+                throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "R4", t.ToString());
         }
 
         private protected override Aggregator GetAggregatorCore(RoleMappedSchema schema, string stratName)
diff --git a/src/Microsoft.ML.TimeSeries/AdaptiveSingularSpectrumSequenceModeler.cs b/src/Microsoft.ML.TimeSeries/AdaptiveSingularSpectrumSequenceModeler.cs
@@ -1229,7 +1229,7 @@ internal override void Train(RoleMappedData data)
             _host.CheckParam(data.Schema.Feature.HasValue, nameof(data), "Must have features column.");
             var featureCol = data.Schema.Feature.Value;
             if (featureCol.Type != NumberType.Float)
-                throw _host.ExceptParam(nameof(data), "The feature column has  type '{0}', but must be a float.", featureCol.Type);
+                throw _host.ExceptSchemaMismatch(nameof(data), "feature", featureCol.Name, "R4", featureCol.Type.ToString());
 
             Single[] dataArray = new Single[_trainSize];
             int col = featureCol.Index;

Original file line number	Diff line number	Diff line change
`@@ -129,11 +129,11 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)`
`129`	`129`	`var host = Host.SchemaSensitive();`
`130`	`130`	`var t = score.Type;`
`131`	`131`	`if (t.IsVector \|\| t.ItemType != NumberType.Float)`
`132`		`- throw host.SchemaSensitive().Except("Score column '{0}' has type '{1}' but must be R4", score, t);`
	`132`	`+ throw host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "R4", t.ToString());`
`133`	`133`	`host.Check(schema.Label.HasValue, "Could not find the label column");`
`134`	`134`	`t = schema.Label.Value.Type;`
`135`	`135`	`if (t != NumberType.R4 && t != NumberType.R8 && t != BoolType.Instance && t.KeyCount != 2)`
`136`		`- throw host.SchemaSensitive().Except("Label column '{0}' has type '{1}' but must be R4, R8, BL or a 2-value key", schema.Label.Value.Name, t);`
	`136`	`+ throw host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name, "R4, R8, BL or a 2-value key", t.ToString());`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`private protected override void CheckCustomColumnTypesCore(RoleMappedSchema schema)`
`@@ -142,14 +142,14 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche`
`142`	`142`	`var host = Host.SchemaSensitive();`
`143`	`143`	`if (prob != null)`
`144`	`144`	`{`
`145`		`- host.Check(prob.Count == 1, "Cannot have multiple probability columns");`
	`145`	`+ host.CheckParam(prob.Count == 1, nameof(schema), "Cannot have multiple probability columns");`
`146`	`146`	`var probType = prob[0].Type;`
`147`	`147`	`if (probType != NumberType.Float)`
`148`		`- throw host.SchemaSensitive().Except("Probability column '{0}' has type '{1}' but must be R4", prob[0].Name, probType);`
	`148`	`+ throw host.ExceptSchemaMismatch(nameof(schema), "probability", prob[0].Name, "R4", probType.ToString());`
`149`	`149`	`}`
`150`	`150`	`else if (!_useRaw)`
`151`	`151`	`{`
`152`		`- throw host.Except(`
	`152`	`+ throw host.ExceptParam(nameof(schema),`
`153`	`153`	`"Cannot compute the predicted label from the probability column because it does not exist");`
`154`	`154`	`}`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -99,15 +99,14 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)`
`99`	`99`	`ColumnType type = schema.Label?.Type;`
`100`	`100`	`if (type != null && type != NumberType.Float && !(type is KeyType keyType && keyType.Count > 0))`
`101`	`101`	`{`
`102`		`- throw Host.Except("Clustering evaluator: label column '{0}' type must be {1} or Key of known cardinality." +`
`103`		`- " Provide a correct label column, or none: it is optional.",`
`104`		`- schema.Label.Value.Name, NumberType.Float);`
	`102`	`+ throw Host.ExceptSchemaMismatch(nameof(schema), "label", schema.Label.Value.Name,`
	`103`	`+ "R4 or key of known cardinality", type.ToString());`
`105`	`104`	`}`
`106`	`105`
`107`	`106`	`var score = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);`
`108`	`107`	`type = score.Type;`
`109`	`108`	`if (!type.IsKnownSizeVector \|\| type.ItemType != NumberType.Float)`
`110`		`- throw Host.Except("Scores column '{0}' type must be a float vector of known size", score.Name);`
	`109`	`+ throw Host.ExceptSchemaMismatch(nameof(schema), "score", score.Name, "R4 vector of known size", type.ToString());`
`111`	`110`	`}`
`112`	`111`
`113`	`112`	`private protected override void CheckCustomColumnTypesCore(RoleMappedSchema schema)`
`@@ -118,8 +117,8 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche`
`118`	`117`	`var t = schema.Feature.Value.Type;`
`119`	`118`	`if (!t.IsKnownSizeVector \|\| t.ItemType != NumberType.Float)`
`120`	`119`	`{`
`121`		`- throw Host.Except("Features column '{0}' type must be {1} vector of known-size",`
`122`		`- schema.Feature.Value.Name, NumberType.Float);`
	`120`	`+ throw Host.ExceptSchemaMismatch(nameof(schema), "features", schema.Feature.Value.Name,`
	`121`	`+ "R4 vector of known size", t.ToString());`
`123`	`122`	`}`
`124`	`123`	`}`
`125`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,14 +89,14 @@ private protected override void CheckScoreAndLabelTypes(RoleMappedSchema schema)`
`89`	`89`	`var t = schema.Label.Value.Type;`
`90`	`90`	`if (t != NumberType.Float && !(t is KeyType))`
`91`	`91`	`{`
`92`		`- throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.LabelColumn), "Label column '{0}' has type '{1}' but must be R4 or a key",`
`93`		`- schema.Label.Value.Name, t);`
	`92`	`+ throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.LabelColumn),`
	`93`	`+ "label", schema.Label.Value.Name, "R4 or a key", t.ToString());`
`94`	`94`	`}`
`95`		`- var scoreInfo = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);`
`96`		`- if (scoreInfo.Type != NumberType.Float)`
	`95`	`+ var scoreCol = schema.GetUniqueColumn(MetadataUtils.Const.ScoreValueKind.Score);`
	`96`	`+ if (scoreCol.Type != NumberType.Float)`
`97`	`97`	`{`
`98`		`- throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.ScoreColumn), "Score column '{0}' has type '{1}' but must be R4",`
`99`		`- scoreInfo.Name, t);`
	`98`	`+ throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.ScoreColumn),`
	`99`	`+ "score", scoreCol.Name, "R4", t.ToString());`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`@@ -105,9 +105,8 @@ private protected override void CheckCustomColumnTypesCore(RoleMappedSchema sche`
`105`	`105`	`var t = schema.Group.Value.Type;`
`106`	`106`	`if (!(t is KeyType))`
`107`	`107`	`{`
`108`		`- throw Host.ExceptUserArg(nameof(RankerMamlEvaluator.Arguments.GroupIdColumn),`
`109`		`- "Group column '{0}' has type '{1}' but must be a key",`
`110`		`- schema.Group.Value.Name, t);`
	`108`	`+ throw Host.ExceptSchemaMismatch(nameof(RankerMamlEvaluator.Arguments.GroupIdColumn),`
	`109`	`+ "group", schema.Group.Value.Name, "key", t.ToString());`
`111`	`110`	`}`
`112`	`111`	`}`
`113`	`112`