Repository: ludwig-ai/ludwig

Issue:
Troubles with visualisation
Hello, I am having troubles with visualising using the few commands of code here, I am hoping you could advise me. 

**This is the training and testing codes:**
![rain troubleshoot1](https://user-images.githubusercontent.com/43140909/65309715-396a1200-dbbf-11e9-9227-3aa1701f40e7.JPG)
**This is the one for learning curves which I have no problems in generating**
![rain troubleshoot2](https://user-images.githubusercontent.com/43140909/65309782-5dc5ee80-dbbf-11e9-8f0b-721dba9eb1f3.JPG)
**For Learning curves**
I cannot seem to figure what files i could use for the probability and ground truth and not sure if they are the correct ones. 
![rain troubleshoot3](https://user-images.githubusercontent.com/43140909/65309988-d331bf00-dbbf-11e9-96fa-e249a1bd97e7.JPG)
**For Confusion matrix**
Same issue, not sure which are my fields are, hence I am getting many errors.
![rain troubleshoot4](https://user-images.githubusercontent.com/43140909/65310057-01af9a00-dbc0-11e9-96a7-10876e6ba00f.JPG)


For further information, the only data that appear in my results are as follows:

![rain troubleshoot5](https://user-images.githubusercontent.com/43140909/65310176-49362600-dbc0-11e9-9097-9d0dd283e25a.JPG)
![rain troubleshoot6](https://user-images.githubusercontent.com/43140909/65310179-49362600-dbc0-11e9-88d5-1e9f7b7a1a7e.JPG)


It would be great if you could advise me . Thank you very much.


Discussion:
@SSicaaJL we're going to work on improving the visualization documentation. In the meantime, follow this for confidence thresholding:

```code
def confidence_thresholding_cli(
        probabilities,
        ground_truth,
        ground_truth_split,
        field,
        **kwargs
):
    """Load model data from files to be shown by confidence_thresholding.

    :param probabilities: Path to experiment probabilities file
    :param ground_truth: Path to ground truth file
    :param ground_truth_split: Type of ground truth split - train, val, test
    :param field: Target prediction field
    :param kwargs: model configuration arguments
    :return None:
    """
```

for confusion matrix:
```code
def confusion_matrix_cli(test_statistics, ground_truth_metadata, **kwargs):
    """Load model data from files to be shown by confusion_matrix.

    :param test_statistics: Path to experiment test statistics file
    :param ground_truth_metadata: Path to ground truth metadata file
    :param kwargs: model configuration arguments
    :return None:
    """
```

sorry for the late response. 
@SSicaaJL
The filed parameter is the name of the column / output feature you want to visualize. In your case it would be `field = "RainTomorrow"`.

For the learning curves:
I don't know how you obtained train_stats. If you got it from the API `model.train()` you can use it as it is, otherwise you just have to load the `training_statistics.json` file that was saved at the end of training. After you do that `learning_curves(train_stats, field, output_directory=output_dir, file_format='png')` should work.

For the confusion matrix:
just use the field parameter as i specified and your command should work.

Will update the docs to try to explain better what is `field`. Please conferm this solves your issues.

Resolving patch:
diff --git a/ludwig/utils/visualization_utils.py b/ludwig/utils/visualization_utils.py
--- a/ludwig/utils/visualization_utils.py
+++ b/ludwig/utils/visualization_utils.py
@@ -624,7 +624,7 @@ def confidence_fitlering_3d_plot(
         thresholds_2,
         accuracies,
         dataset_kepts,
-        threshold_fields=None,
+        threshold_output_feature_names=None,
         title=None,
         filename=None
 ):
@@ -651,8 +651,8 @@ def confidence_fitlering_3d_plot(
     ax.grid(which='minor', alpha=0.5)
     ax.grid(which='major', alpha=0.75)
 
-    ax.set_xlabel('{} probability'.format(threshold_fields[0]))
-    ax.set_ylabel('{} probability'.format(threshold_fields[1]))
+    ax.set_xlabel('{} probability'.format(threshold_output_feature_names[0]))
+    ax.set_ylabel('{} probability'.format(threshold_output_feature_names[1]))
 
     ax.set_xlim(np.min(thresholds_1), np.max(thresholds_1))
     ax.set_ylim(np.min(thresholds_2), np.max(thresholds_2))
@@ -938,7 +938,7 @@ def predictions_distribution_plot(
 def confusion_matrix_plot(
         confusion_matrix,
         labels=None,
-        field=None,
+        output_feature_name=None,
         filename=None
 ):
     mpl.rcParams.update({'figure.autolayout': True})
@@ -957,8 +957,8 @@ def confusion_matrix_plot(
     ax.grid(False)
     ax.tick_params(axis='both', which='both', length=0)
     fig.colorbar(cax, ax=ax, extend='max')
-    ax.set_xlabel('Predicted {}'.format(field))
-    ax.set_ylabel('Actual {}'.format(field))
+    ax.set_xlabel('Predicted {}'.format(output_feature_name))
+    ax.set_ylabel('Actual {}'.format(output_feature_name))
 
     plt.tight_layout()
     ludwig.contrib.contrib_command("visualize_figure", plt.gcf())
diff --git a/ludwig/visualize.py b/ludwig/visualize.py
--- a/ludwig/visualize.py
+++ b/ludwig/visualize.py
@@ -40,17 +40,17 @@
 
 
 def validate_conf_treshholds_and_probabilities_2d_3d(
-        probabilities, treshhold_fields
+        probabilities, treshhold_output_feature_names
 ):
-    """Ensure probabilities and treshhold fields arrays have two members each.
+    """Ensure probabilities and treshhold output_feature_names arrays have two members each.
 
     :param probabilities: List of probabilities per model
-    :param threshhold_fields: List of threshhold fields per model
+    :param threshhold_output_feature_names: List of threshhold output_feature_names per model
     :raise: RuntimeError
     """
     validation_mapping = {
         'probabilities': probabilities,
-        'treshhold_fields': treshhold_fields
+        'treshhold_output_feature_names': treshhold_output_feature_names
     }
     for item, value in validation_mapping.items():
         item_len = len(value)
@@ -101,47 +101,53 @@ def convert_to_list(item):
     return item if item is None or isinstance(item, list) else [item]
 
 
-def validate_visualization_prediction_field_from_train_stats(
-        field,
+def _validate_output_feature_name_from_train_stats(
+        output_feature_name,
         train_stats_per_model
 ):
-    """Validate prediction field from model train stats and return it as list.
+    """Validate prediction output_feature_name from model train stats and return it as list.
 
-    :param field: field containing ground truth
+    :param output_feature_name: output_feature_name containing ground truth
     :param train_stats_per_model: list of per model train stats
-    :return fields: list of field(s) containing ground truth
+    :return output_feature_names: list of output_feature_name(s) containing ground truth
     """
-    fields_set = set()
+    output_feature_names_set = set()
     for ls in train_stats_per_model:
         for _, values in ls.items():
             for key in values:
-                fields_set.add(key)
+                output_feature_names_set.add(key)
     try:
-        return [field] if field in fields_set else fields_set
-    # raised if field is emtpy iterable (e.g. [] in set())
+        if output_feature_name in output_feature_names_set:
+            return [output_feature_name]
+        else:
+            return output_feature_names_set
+    # raised if output_feature_name is emtpy iterable (e.g. [] in set())
     except TypeError:
-        return fields_set
+        return output_feature_names_set
 
 
-def validate_visualization_prediction_field_from_test_stats(
-        field,
+def _validate_output_feature_name_from_test_stats(
+        output_feature_name,
         test_stats_per_model
 ):
-    """Validate prediction field from model test stats and return it as list.
+    """Validate prediction output_feature_name from model test stats and return it as list.
 
-    :param field: field containing ground truth
+    :param output_feature_name: output_feature_name containing ground truth
     :param test_stats_per_model: list of per model test stats
-    :return fields: list of field(s) containing ground truth
+    :return output_feature_names: list of output_feature_name(s) containing ground truth
     """
-    fields_set = set()
+    output_feature_names_set = set()
     for ls in test_stats_per_model:
         for key in ls:
-            fields_set.add(key)
+            output_feature_names_set.add(key)
     try:
-        return [field] if field in fields_set else fields_set
-    # raised if field is emtpy iterable (e.g. [] in set())
+        if output_feature_name in output_feature_names_set:
+            return [output_feature_name]
+        else:
+            return output_feature_names_set
+    # raised if output_feature_name is emtpy iterable (e.g. [] in set())
     except TypeError:
-        return fields_set
+        return output_feature_names_set
 
 
 def generate_filename_template_path(output_dir, filename_template):
@@ -186,7 +192,7 @@ def compare_classifiers_performance_from_prob_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_from_prob.
@@ -194,11 +200,11 @@ def compare_classifiers_performance_from_prob_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -212,7 +218,7 @@ def compare_classifiers_performance_from_pred_cli(
         ground_truth,
         ground_truth_metadata,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_from_pred
@@ -221,11 +227,11 @@ def compare_classifiers_performance_from_pred_cli(
     :param ground_truth: Path to ground truth file
     :param ground_truth_metadata: Path to ground truth metadata file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     metadata = load_json(ground_truth_metadata)
     predictions_per_model_raw = load_data_for_viz(
         'load_from_file', predictions, dtype=str
@@ -234,7 +240,7 @@ def compare_classifiers_performance_from_pred_cli(
         np.ndarray.flatten(pred) for pred in predictions_per_model_raw
     ]
     compare_classifiers_performance_from_pred(
-        predictions_per_model, gt, metadata, field, **kwargs
+        predictions_per_model, gt, metadata, output_feature_name, **kwargs
     )
 
 
@@ -242,7 +248,7 @@ def compare_classifiers_performance_subset_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_subset.
@@ -250,11 +256,11 @@ def compare_classifiers_performance_subset_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -267,7 +273,7 @@ def compare_classifiers_performance_changing_k_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_changing_k.
@@ -275,11 +281,11 @@ def compare_classifiers_performance_changing_k_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -310,7 +316,7 @@ def compare_classifiers_predictions_cli(
         predictions,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_predictions
@@ -318,11 +324,11 @@ def compare_classifiers_predictions_cli(
     :param predictions: Path to experiment predictions file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     predictions_per_model = load_data_for_viz(
         'load_from_file', predictions, dtype=str
     )
@@ -333,7 +339,7 @@ def compare_classifiers_predictions_distribution_cli(
         predictions,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by
@@ -342,11 +348,11 @@ def compare_classifiers_predictions_distribution_cli(
     :param predictions: Path to experiment predictions file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     predictions_per_model = load_data_for_viz(
         'load_from_file', predictions, dtype=str
     )
@@ -359,7 +365,7 @@ def confidence_thresholding_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by confidence_thresholding.
@@ -367,11 +373,11 @@ def confidence_thresholding_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -384,7 +390,7 @@ def confidence_thresholding_data_vs_acc_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by
@@ -393,11 +399,11 @@ def confidence_thresholding_data_vs_acc_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -410,7 +416,7 @@ def confidence_thresholding_data_vs_acc_subset_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by
@@ -419,11 +425,11 @@ def confidence_thresholding_data_vs_acc_subset_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -437,7 +443,7 @@ def confidence_thresholding_data_vs_acc_subset_per_class_cli(
         ground_truth,
         ground_truth_metadata,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by compare_classifiers_multiclass
@@ -446,17 +452,17 @@ def confidence_thresholding_data_vs_acc_subset_per_class_cli(
     :param ground_truth: Path to ground truth file
     :param ground_truth_metadata: Path to ground truth metadata file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
     metadata = load_json(ground_truth_metadata)
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
     confidence_thresholding_data_vs_acc_subset_per_class(
-        probabilities_per_model, gt, metadata, field, **kwargs
+        probabilities_per_model, gt, metadata, output_feature_name, **kwargs
     )
 
 
@@ -464,7 +470,7 @@ def confidence_thresholding_2thresholds_2d_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        threshold_fields,
+        threshold_output_feature_names,
         **kwargs
 ):
     """Load model data from files to be shown by
@@ -473,25 +479,25 @@ def confidence_thresholding_2thresholds_2d_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param threshold_fields: Target prediction fields
+    :param threshold_output_feature_names: Name of the output feature to visualizes
     :param kwargs: model configuration arguments
     :return None:
     """
     gt1 = load_from_file(
         ground_truth,
-        threshold_fields[0],
+        threshold_output_feature_names[0],
         ground_truth_split
     )
     gt2 = load_from_file(
         ground_truth,
-        threshold_fields[1],
+        threshold_output_feature_names[1],
         ground_truth_split
     )
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
     confidence_thresholding_2thresholds_2d(
-        probabilities_per_model, [gt1, gt2], threshold_fields, **kwargs
+        probabilities_per_model, [gt1, gt2], threshold_output_feature_names, **kwargs
     )
 
 
@@ -499,7 +505,7 @@ def confidence_thresholding_2thresholds_3d_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        threshold_fields,
+        threshold_output_feature_names,
         **kwargs
 ):
     """Load model data from files to be shown by
@@ -508,25 +514,25 @@ def confidence_thresholding_2thresholds_3d_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param threshold_fields: Target prediction fields
+    :param threshold_output_feature_names: Names of the output features to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
     gt1 = load_from_file(
         ground_truth,
-        threshold_fields[0],
+        threshold_output_feature_names[0],
         ground_truth_split
     )
     gt2 = load_from_file(
         ground_truth,
-        threshold_fields[1],
+        threshold_output_feature_names[1],
         ground_truth_split
     )
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
     confidence_thresholding_2thresholds_3d(
-        probabilities_per_model, [gt1, gt2], threshold_fields, **kwargs
+        probabilities_per_model, [gt1, gt2], threshold_output_feature_names, **kwargs
     )
 
 
@@ -534,7 +540,7 @@ def binary_threshold_vs_metric_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by binary_threshold_vs_metric_cli.
@@ -542,11 +548,11 @@ def binary_threshold_vs_metric_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -559,7 +565,7 @@ def roc_curves_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by roc_curves_cli.
@@ -567,11 +573,11 @@ def roc_curves_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -596,7 +602,7 @@ def calibration_1_vs_all_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by calibration_1_vs_all_cli.
@@ -604,11 +610,11 @@ def calibration_1_vs_all_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -619,7 +625,7 @@ def calibration_multiclass_cli(
         probabilities,
         ground_truth,
         ground_truth_split,
-        field,
+        output_feature_name,
         **kwargs
 ):
     """Load model data from files to be shown by calibration_multiclass_cli.
@@ -627,11 +633,11 @@ def calibration_multiclass_cli(
     :param probabilities: Path to experiment probabilities file
     :param ground_truth: Path to ground truth file
     :param ground_truth_split: Type of ground truth split - train, val, test
-    :param field: Target prediction field
+    :param output_feature_name: Name of the output feature to visualize
     :param kwargs: model configuration arguments
     :return None:
     """
-    gt = load_from_file(ground_truth, field, ground_truth_split)
+    gt = load_from_file(ground_truth, output_feature_name, ground_truth_split)
     probabilities_per_model = load_data_for_viz(
         'load_from_file', probabilities, dtype=float
     )
@@ -666,7 +672,7 @@ def frequency_vs_f1_cli(test_statistics, ground_truth_metadata, **kwargs):
 
 def learning_curves(
         train_stats_per_model,
-        field,
+        output_feature_name,
         model_names=None,
         output_directory=None,
         file_format='pdf',
@@ -678,7 +684,8 @@ def learning_curves(
      it produces a line plot showing how that measure changed over the course
      of the epochs of training on the training and validation sets.
     :param train_stats_per_model: List containing train statistics per model
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted 
+           and for which is provided ground truth
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
              If not specified, plots will be displayed in a window
@@ -692,20 +699,20 @@ def learning_curves(
     )
     train_stats_per_model_list = convert_to_list(train_stats_per_model)
     model_names_list = convert_to_list(model_names)
-    fields = validate_visualization_prediction_field_from_train_stats(
-        field,
+    output_feature_names = _validate_output_feature_name_from_train_stats(
+        output_feature_name,
         train_stats_per_model_list
     )
 
     metrics = [LOSS, ACCURACY, HITS_AT_K, EDIT_DISTANCE]
-    for field in fields:
+    for output_feature_name in output_feature_names:
         for metric in metrics:
-            if metric in train_stats_per_model_list[0]['train'][field]:
+            if metric in train_stats_per_model_list[0]['train'][output_feature_name]:
                 filename = None
                 if filename_template_path:
-                    filename = filename_template_path.format(field, metric)
+                    filename = filename_template_path.format(output_feature_name, metric)
 
-                training_stats = [learning_stats['train'][field][metric]
+                training_stats = [learning_stats['train'][output_feature_name][metric]
                                   for learning_stats in
                                   train_stats_per_model_list]
 
@@ -713,7 +720,7 @@ def learning_curves(
                 for learning_stats in train_stats_per_model_list:
                     if 'validation' in learning_stats:
                         validation_stats.append(
-                            learning_stats['validation'][field][metric]
+                            learning_stats['validation'][output_feature_name][metric]
                         )
                     else:
                         validation_stats.append(None)
@@ -723,14 +730,14 @@ def learning_curves(
                     validation_stats,
                     metric,
                     model_names_list,
-                    title='Learning Curves {}'.format(field),
+                    title='Learning Curves {}'.format(output_feature_name),
                     filename=filename
                 )
 
 
 def compare_performance(
         test_stats_per_model,
-        field, model_names=None,
+        output_feature_name, model_names=None,
         output_directory=None,
         file_format='pdf',
         **kwargs
@@ -740,9 +747,9 @@ def compare_performance(
 
     For each model (in the aligned lists of test_statistics and model_names)
     it produces bars in a bar plot, one for each overall metric available
-    in the test_statistics file for the specified field.
+    in the test_statistics file for the specified output_feature_name.
     :param test_stats_per_model: List containing train statistics per model
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted and for which is provided ground truth
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
              If not specified, plots will be displayed in a window
@@ -757,24 +764,24 @@ def compare_performance(
 
     test_stats_per_model_list = convert_to_list(test_stats_per_model)
     model_names_list = convert_to_list(model_names)
-    fields = validate_visualization_prediction_field_from_test_stats(
-        field,
+    output_feature_names = _validate_output_feature_name_from_test_stats(
+        output_feature_name,
         test_stats_per_model_list
     )
 
-    for field in fields:
+    for output_feature_name in output_feature_names:
         accuracies = []
         hits_at_ks = []
         edit_distances = []
 
         for test_stats_per_model in test_stats_per_model_list:
-            if ACCURACY in test_stats_per_model[field]:
-                accuracies.append(test_stats_per_model[field][ACCURACY])
-            if HITS_AT_K in test_stats_per_model[field]:
-                hits_at_ks.append(test_stats_per_model[field][HITS_AT_K])
-            if EDIT_DISTANCE in test_stats_per_model[field]:
+            if ACCURACY in test_stats_per_model[output_feature_name]:
+                accuracies.append(test_stats_per_model[output_feature_name][ACCURACY])
+            if HITS_AT_K in test_stats_per_model[output_feature_name]:
+                hits_at_ks.append(test_stats_per_model[output_feature_name][HITS_AT_K])
+            if EDIT_DISTANCE in test_stats_per_model[output_feature_name]:
                 edit_distances.append(
-                    test_stats_per_model[field][EDIT_DISTANCE])
+                    test_stats_per_model[output_feature_name][EDIT_DISTANCE])
 
         measures = []
         measures_names = []
@@ -791,14 +798,14 @@ def compare_performance(
         filename = None
 
         if filename_template_path:
-            filename = filename_template_path.format(field)
+            filename = filename_template_path.format(output_feature_name)
             os.makedirs(output_directory, exist_ok=True)
 
         visualization_utils.compare_classifiers_plot(
             measures,
             measures_names,
             model_names_list,
-            title='Performance comparison on {}'.format(field),
+            title='Performance comparison on {}'.format(output_feature_name),
             filename=filename
         )
 
@@ -817,10 +824,9 @@ def compare_classifiers_performance_from_prob(
 
     For each model it produces bars in a bar plot, one for each overall metric
     computed on the fly from the probabilities of predictions for the specified
-    field.
+    output_feature_name.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param top_n_classes: List containing the number of classes to plot
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
@@ -887,7 +893,7 @@ def compare_classifiers_performance_from_pred(
         predictions_per_model,
         ground_truth,
         metadata,
-        field,
+        output_feature_name,
         labels_limit,
         model_names=None,
         output_directory=None,
@@ -897,13 +903,12 @@ def compare_classifiers_performance_from_pred(
     """Produces model comparision barplot visualization from predictions.
 
     For each model it produces bars in a bar plot, one for each overall metric
-    computed on the fly from the predictions for the specified field.
+    computed on the fly from the predictions for the specified output_feature_name.
     :param predictions_per_model: List containing the model predictions
-           for the specified field
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+           for the specified output_feature_name
+    :param ground_truth: NumPy Array containing ground truth data
     :param metadata: Model's input metadata
-    :param field: field containing ground truth
+    :param output_feature_name: output_feature_name containing ground truth
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -920,7 +925,7 @@ def compare_classifiers_performance_from_pred(
     mapped_preds = []
     try:
         for pred in preds:
-            mapped_preds.append([metadata[field]['str2idx'][val] for val in
+            mapped_preds.append([metadata[output_feature_name]['str2idx'][val] for val in
                                  pred])
         preds = mapped_preds
     # If predictions are coming from npy file there is no need to convert to
@@ -979,12 +984,11 @@ def compare_classifiers_performance_subset(
 
     For each model  it produces bars in a bar plot, one for each overall metric
      computed on the fly from the probabilities predictions for the
-     specified field, considering only a subset of the full training set.
+     specified output_feature_name, considering only a subset of the full training set.
      The way the subset is obtained is using the top_n_classes and
      subset parameters.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param top_n_classes: List containing the number of classes to plot
     :param labels_limit: Maximum numbers of labels.
     :param subset: Type of the subset filtering
@@ -1091,11 +1095,10 @@ def compare_classifiers_performance_changing_k(
 
     For each model it produces a line plot that shows the Hits@K measure
     (that counts a prediction as correct if the model produces it among the
-    first k) while changing k from 1 to top_k for the specified field.
+    first k) while changing k from 1 to top_k for the specified output_feature_name.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
-    param top_k: Number of elements in the ranklist to consider
+    :param ground_truth: NumPy Array containing ground truth data
+    :param top_k: Number of elements in the ranklist to consider
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -1146,20 +1149,20 @@ def compare_classifiers_performance_changing_k(
 def compare_classifiers_multiclass_multimetric(
         test_stats_per_model,
         metadata,
-        field,
+        output_feature_name,
         top_n_classes,
         model_names=None,
         output_directory=None,
         file_format='pdf',
         **kwargs
 ):
-    """Show the precision, recall and F1 of the model for the specified field.
+    """Show the precision, recall and F1 of the model for the specified output_feature_name.
 
     For each model it produces four plots that show the precision,
-    recall and F1 of the model on several classes for the specified field.
+    recall and F1 of the model on several classes for the specified output_feature_name.
     :param test_stats_per_model: List containing train statistics per model
     :param metadata: Model's input metadata
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted and for which is provided ground truth
     :param top_n_classes: List containing the number of classes to plot
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
@@ -1177,32 +1180,32 @@ def compare_classifiers_multiclass_multimetric(
 
     test_stats_per_model_list = convert_to_list(test_stats_per_model)
     model_names_list = convert_to_list(model_names)
-    fields = validate_visualization_prediction_field_from_test_stats(
-        field,
+    output_feature_names = _validate_output_feature_name_from_test_stats(
+        output_feature_name,
         test_stats_per_model_list
     )
 
     for i, test_statistics in enumerate(
             test_stats_per_model_list):
-        for field in fields:
+        for output_feature_name in output_feature_names:
             model_name_name = (
                 model_names_list[i]
                 if model_names_list is not None and i < len(model_names_list)
                 else ''
             )
-            if 'per_class_stats' not in test_statistics[field]:
+            if 'per_class_stats' not in test_statistics[output_feature_name]:
                 logging.warning(
-                    'The field {} in test statistics does not contain "{}", '
-                    'skipping it'.format(field, per_class_stats)
+                    'The output_feature_name {} in test statistics does not contain "{}", '
+                    'skipping it'.format(output_feature_name, per_class_stats)
                 )
                 break
-            per_class_stats = test_statistics[field]['per_class_stats']
+            per_class_stats = test_statistics[output_feature_name]['per_class_stats']
             precisions = []
             recalls = []
             f1_scores = []
             labels = []
             for _, class_name in sorted(
-                    [(metadata[field]['str2idx'][key], key)
+                    [(metadata[output_feature_name]['str2idx'][key], key)
                      for key in per_class_stats.keys()],
                     key=lambda tup: tup[0]):
                 class_stats = per_class_stats[class_name]
@@ -1221,7 +1224,7 @@ def compare_classifiers_multiclass_multimetric(
                 if filename_template_path:
                     os.makedirs(output_directory, exist_ok=True)
                     filename = filename_template_path.format(
-                        model_name_name, field, 'top{}'.format(k)
+                        model_name_name, output_feature_name, 'top{}'.format(k)
                     )
 
                 visualization_utils.compare_classifiers_multiclass_multimetric_plot(
@@ -1230,7 +1233,7 @@ def compare_classifiers_multiclass_multimetric(
                     labels=ls,
                     title='{} Multiclass Precision / Recall / '
                           'F1 Score top {} {}'.format(model_name_name, k,
-                                                      field),
+                                                      output_feature_name),
                     filename=filename
                 )
 
@@ -1245,7 +1248,7 @@ def compare_classifiers_multiclass_multimetric(
                 if filename_template_path:
                     os.makedirs(output_directory, exist_ok=True)
                     filename = filename_template_path.format(
-                        model_name_name, field, 'best{}'.format(k)
+                        model_name_name, output_feature_name, 'best{}'.format(k)
                     )
                 visualization_utils.compare_classifiers_multiclass_multimetric_plot(
                     [p_np[higher_f1s],
@@ -1255,14 +1258,14 @@ def compare_classifiers_multiclass_multimetric(
                     labels=labels_np[higher_f1s].tolist(),
                     title='{} Multiclass Precision / Recall / '
                           'F1 Score best {} classes {}'.format(
-                        model_name_name, k, field),
+                        model_name_name, k, output_feature_name),
                     filename=filename
                 )
                 lower_f1s = sorted_indices[:k]
                 filename = None
                 if filename_template_path:
                     filename = filename_template_path.format(
-                        model_name_name, field, 'worst{}'.format(k)
+                        model_name_name, output_feature_name, 'worst{}'.format(k)
                     )
                 visualization_utils.compare_classifiers_multiclass_multimetric_plot(
                     [p_np[lower_f1s],
@@ -1271,14 +1274,14 @@ def compare_classifiers_multiclass_multimetric(
                     ['precision', 'recall', 'f1 score'],
                     labels=labels_np[lower_f1s].tolist(),
                     title='{} Multiclass Precision / Recall / F1 Score worst '
-                          'k classes {}'.format(model_name_name, k, field),
+                          'k classes {}'.format(model_name_name, k, output_feature_name),
                     filename=filename
                 )
 
                 filename = None
                 if filename_template_path:
                     filename = filename_template_path.format(
-                        model_name_name, field, 'sorted'
+                        model_name_name, output_feature_name, 'sorted'
                     )
                 visualization_utils.compare_classifiers_multiclass_multimetric_plot(
                     [p_np[sorted_indices[::-1]],
@@ -1287,26 +1290,26 @@ def compare_classifiers_multiclass_multimetric(
                     ['precision', 'recall', 'f1 score'],
                     labels=labels_np[sorted_indices[::-1]].tolist(),
                     title='{} Multiclass Precision / Recall / F1 Score '
-                          '{} sorted'.format(model_name_name, field),
+                          '{} sorted'.format(model_name_name, output_feature_name),
                     filename=filename
                 )
 
                 logging.info('\n')
                 logging.info(model_name_name)
-                tmp_str = '{0} best 5 classes: '.format(field)
+                tmp_str = '{0} best 5 classes: '.format(output_feature_name)
                 tmp_str += '{}'
                 logging.info(tmp_str.format(higher_f1s))
                 logging.info(f1_np[higher_f1s])
-                tmp_str = '{0} worst 5 classes: '.format(field)
+                tmp_str = '{0} worst 5 classes: '.format(output_feature_name)
                 tmp_str += '{}'
                 logging.info(tmp_str.format(lower_f1s))
                 logging.info(f1_np[lower_f1s])
                 tmp_str = '{0} number of classes with f1 score > 0: '.format(
-                    field)
+                    output_feature_name)
                 tmp_str += '{}'
                 logging.info(tmp_str.format(np.sum(f1_np > 0)))
                 tmp_str = '{0} number of classes with f1 score = 0: '.format(
-                    field)
+                    output_feature_name)
                 tmp_str += '{}'
                 logging.info(tmp_str.format(np.sum(f1_np == 0)))
 
@@ -1320,11 +1323,10 @@ def compare_classifiers_predictions(
         file_format='pdf',
         **kwargs
 ):
-    """Show two models comparision of their field predictions.
+    """Show two models comparision of their output_feature_name predictions.
 
     :param predictions_per_model: List containing the model predictions
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -1450,13 +1452,12 @@ def compare_classifiers_predictions_distribution(
         file_format='pdf',
         **kwargs
 ):
-    """Show comparision of models predictions distribution for 10 field classes
+    """Show comparision of models predictions distribution for 10 output_feature_name classes
 
     This visualization produces a radar plot comparing the distributions of
-    predictions of the models for the first 10 classes of the specified field.
+    predictions of the models for the first 10 classes of the specified output_feature_name.
     :param predictions_per_model: List containing the model predictions
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -1515,10 +1516,9 @@ def confidence_thresholding(
 
     For each model it produces a pair of lines indicating the accuracy of
     the model and the data coverage while increasing a threshold (x axis) on
-    the probabilities of predictions for the specified field.
+    the probabilities of predictions for the specified output_feature_name.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -1596,13 +1596,12 @@ def confidence_thresholding_data_vs_acc(
 
     For each model it produces a line indicating the accuracy of the model
     and the data coverage while increasing a threshold on the probabilities
-    of predictions for the specified field. The difference with
+    of predictions for the specified output_feature_name. The difference with
     confidence_thresholding is that it uses two axes instead of three,
     not visualizing the threshold and having coverage as x axis instead of
     the threshold.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -1680,7 +1679,7 @@ def confidence_thresholding_data_vs_acc_subset(
 
     For each model it produces a line indicating the accuracy of the model
     and the data coverage while increasing a threshold on the probabilities
-    of predictions for the specified field, considering only a subset of the
+    of predictions for the specified output_feature_name, considering only a subset of the
     full training set. The way the subset is obtained is using the top_n_classes
     and subset parameters.
      The difference with confidence_thresholding is that it uses two axes
@@ -1696,8 +1695,7 @@ def confidence_thresholding_data_vs_acc_subset(
      and the percentage of datapoints that have been kept from the original set
      will be displayed for each model.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param top_n_classes: List containing the number of classes to plot
     :param labels_limit: Maximum numbers of labels.
     :param subset: Type of the subset filtering
@@ -1788,7 +1786,7 @@ def confidence_thresholding_data_vs_acc_subset_per_class(
         probabilities_per_model,
         ground_truth,
         metadata,
-        field,
+        output_feature_name,
         top_n_classes,
         labels_limit,
         subset,
@@ -1803,7 +1801,7 @@ def confidence_thresholding_data_vs_acc_subset_per_class(
     For each model (in the aligned lists of probabilities and model_names)
     it produces a line indicating the accuracy of the model and the data
     coverage while increasing a threshold on the probabilities of
-    predictions for the specified field, considering only a subset of the
+    predictions for the specified output_feature_name, considering only a subset of the
     full training set. The way the subset is obtained is using the
     top_n_classes  and subset parameters.  The difference with
     confidence_thresholding is that it uses two axes instead of three,
@@ -1822,8 +1820,7 @@ def confidence_thresholding_data_vs_acc_subset_per_class(
     The difference with confidence_thresholding_data_vs_acc_subset is that it
     produces one plot per class within the top_n_classes.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param metadata: Model's input metadata
     :param top_n_classes: List containing the number of classes to plot
     :param labels_limit: Maximum numbers of labels.
@@ -1902,18 +1899,18 @@ def confidence_thresholding_data_vs_acc_subset_per_class(
             accuracies.append(accuracies_alg)
             dataset_kept.append(dataset_kept_alg)
 
-        field_name = metadata[field]['idx2str'][curr_k]
+        output_feature_name_name = metadata[output_feature_name]['idx2str'][curr_k]
 
         filename = None
         if filename_template_path:
             os.makedirs(output_directory, exist_ok=True)
-            filename = filename_template_path.format(field_name)
+            filename = filename_template_path.format(output_feature_name_name)
 
         visualization_utils.confidence_fitlering_data_vs_acc_plot(
             accuracies, dataset_kept, model_names_list,
             decimal_digits=2,
             title='Confidence_Thresholding (Data vs Accuracy) '
-                  'for class {}'.format(field_name),
+                  'for class {}'.format(output_feature_name_name),
             filename=filename
         )
 
@@ -1921,26 +1918,24 @@ def confidence_thresholding_data_vs_acc_subset_per_class(
 def confidence_thresholding_2thresholds_2d(
         probabilities_per_model,
         ground_truths,
-        threshold_fields,
+        threshold_output_feature_names,
         labels_limit,
         model_names=None,
         output_directory=None,
         file_format='pdf',
         **kwargs
 ):
-    """Show confidence trethreshold data vs accuracy for two field thresholds
+    """Show confidence trethreshold data vs accuracy for two output_feature_name thresholds
 
     The first plot shows several semi transparent lines. They summarize the
     3d surfaces displayed by confidence_thresholding_2thresholds_3d that have
     thresholds on the confidence of the predictions of the two
-    threshold_fields  as x and y axes and either the data coverage percentage or
+    threshold_output_feature_names  as x and y axes and either the data coverage percentage or
     the accuracy as z axis. Each line represents a slice of the data
     coverage  surface projected onto the accuracy surface.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truths: List of NumPy Arrays containing computed model ground
-               truth data for target prediction fields based on the model
-               metadata
-    :param threshold_fields: List of fields for 2d threshold
+    :param ground_truths: List of NumPy Arrays containing ground truth data
+    :param threshold_output_feature_names: List of output_feature_names for 2d threshold
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: Name of the model to use as label.
@@ -1952,7 +1947,7 @@ def confidence_thresholding_2thresholds_2d(
     try:
         validate_conf_treshholds_and_probabilities_2d_3d(
             probabilities_per_model,
-            threshold_fields
+            threshold_output_feature_names
         )
     except RuntimeError:
         return
@@ -1973,8 +1968,8 @@ def confidence_thresholding_2thresholds_2d(
 
     thresholds = [t / 100 for t in range(0, 101, 5)]
     fixed_step_coverage = thresholds
-    name_t1 = '{} threshold'.format(threshold_fields[0])
-    name_t2 = '{} threshold'.format(threshold_fields[1])
+    name_t1 = '{} threshold'.format(threshold_output_feature_names[0])
+    name_t2 = '{} threshold'.format(threshold_output_feature_names[1])
 
     accuracies = []
     dataset_kept = []
@@ -2112,23 +2107,21 @@ def confidence_thresholding_2thresholds_2d(
 def confidence_thresholding_2thresholds_3d(
         probabilities_per_model,
         ground_truths,
-        threshold_fields,
+        threshold_output_feature_names,
         labels_limit,
         output_directory=None,
         file_format='pdf',
         **kwargs
 ):
-    """Show 3d confidence trethreshold data vs accuracy for two field thresholds
+    """Show 3d confidence trethreshold data vs accuracy for two output_feature_name thresholds
 
     The plot shows the 3d surfaces displayed by
     confidence_thresholding_2thresholds_3d that have thresholds on the
-    confidence of the predictions of the two threshold_fields as x and y axes
+    confidence of the predictions of the two threshold_output_feature_names as x and y axes
     and either the data coverage percentage or the accuracy as z axis.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truths: List of NumPy Arrays containing computed model ground
-               truth data for target prediction fields based on the model
-               metadata
-    :param threshold_fields: List of fields for 2d threshold
+    :param ground_truths: List of NumPy Arrays containing ground truth data
+    :param threshold_output_feature_names: List of output_feature_names for 2d threshold
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param output_directory: Directory where to save plots.
@@ -2139,7 +2132,7 @@ def confidence_thresholding_2thresholds_3d(
     try:
         validate_conf_treshholds_and_probabilities_2d_3d(
             probabilities_per_model,
-            threshold_fields
+            threshold_output_feature_names
         )
     except RuntimeError:
         return
@@ -2216,7 +2209,7 @@ def confidence_thresholding_2thresholds_3d(
         np.array(thresholds),
         np.array(accuracies),
         np.array(dataset_kept),
-        threshold_fields,
+        threshold_output_feature_names,
         title='Confidence_Thresholding, two thresholds',
         filename=filename
     )
@@ -2232,20 +2225,18 @@ def binary_threshold_vs_metric(
         file_format='pdf',
         **kwargs
 ):
-    """Show confidence of the model against metric for the specified field.
+    """Show confidence of the model against metric for the specified output_feature_name.
 
     For each metric specified in metrics (options are f1, precision, recall,
     accuracy), this visualization produces a line chart plotting a threshold
     on  the confidence of the model against the metric for the specified
-    field.  If field is a category feature, positive_label indicates which is
+    output_feature_name.  If output_feature_name is a category feature, positive_label indicates which is
     the class to be considered positive class and all the others will be
     considered negative. It needs to be an integer, to figure out the
     association between classes and integers check the ground_truth_metadata
     JSON file.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: List of NumPy Arrays containing computed model
-           ground truth data for target prediction fields based on the model
-           metadata
+    :param ground_truth: List of NumPy Arrays containing ground truth data
     :param metrics: metrics to dispay (f1, precision, recall,
                     accuracy)
     :param positive_label: Label of the positive class
@@ -2346,18 +2337,16 @@ def roc_curves(
         file_format='pdf',
         **kwargs
 ):
-    """Show the roc curves for the specified models output field.
+    """Show the roc curves for the specified models output output_feature_name.
 
     This visualization produces a line chart plotting the roc curves for the
-    specified field. If field is a category feature, positive_label indicates
+    specified output_feature_name. If output_feature_name is a category feature, positive_label indicates
     which is the class to be considered positive class and all the others will
     be considered negative. It needs to be an integer, to figure out the
     association between classes and integers check the ground_truth_metadata
     JSON file.
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: List of NumPy Arrays containing computed model
-           ground truth data for target prediction fields based on the model
-           metadata
+    :param ground_truth: List of NumPy Arrays containing ground truth data
     :param positive_label: Label of the positive class
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
@@ -2396,19 +2385,19 @@ def roc_curves(
 
 def roc_curves_from_test_statistics(
         test_stats_per_model,
-        field,
+        output_feature_name,
         model_names=None,
         output_directory=None,
         file_format='pdf',
         **kwargs
 ):
-    """Show the roc curves for the specified models output binary field.
+    """Show the roc curves for the specified models output binary output_feature_name.
 
-    This visualization uses the field, test_statistics and model_names
-    parameters. field needs to be binary feature. This visualization produces a
-    line chart plotting the roc curves for the specified field.
+    This visualization uses the output_feature_name, test_statistics and model_names
+    parameters. output_feature_name needs to be binary feature. This visualization produces a
+    line chart plotting the roc curves for the specified output_feature_name.
     :param test_stats_per_model: List containing train statistics per model
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted and for which is provided ground truth
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
              If not specified, plots will be displayed in a window
@@ -2423,9 +2412,9 @@ def roc_curves_from_test_statistics(
     )
     fpr_tprs = []
     for curr_test_statistics in test_stats_per_model:
-        fpr = curr_test_statistics[field]['roc_curve'][
+        fpr = curr_test_statistics[output_feature_name]['roc_curve'][
             'false_positive_rate']
-        tpr = curr_test_statistics[field]['roc_curve'][
+        tpr = curr_test_statistics[output_feature_name]['roc_curve'][
             'true_positive_rate']
         fpr_tprs.append((fpr, tpr))
 
@@ -2447,11 +2436,11 @@ def calibration_1_vs_all(
         file_format='pdf',
         **kwargs
 ):
-    """Show models probability of predictions for the specified field.
+    """Show models probability of predictions for the specified output_feature_name.
 
     For each class or each of the k most frequent classes if top_k is
     specified,  it produces two plots computed on the fly from the
-    probabilities  of predictions for the specified field.
+    probabilities  of predictions for the specified output_feature_name.
 
     The first plot is a calibration curve that shows the calibration of the
     predictions considering the current class to be the true one and all
@@ -2463,8 +2452,7 @@ def calibration_1_vs_all(
     drawing the distribution for each model (in the aligned lists of
     probabilities and model_names).
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param top_n_classes: List containing the number of classes to plot
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
@@ -2579,11 +2567,10 @@ def calibration_multiclass(
         **kwargs
 ):
     """Show models probability of predictions for each class of the the
-    specified field.
+    specified output_feature_name.
 
     :param probabilities_per_model: List of model probabilities
-    :param ground_truth: NumPy Array containing computed model ground truth
-           data for target prediction field based on the model metadata
+    :param ground_truth: NumPy Array containing ground truth data
     :param labels_limit: Maximum numbers of labels.
              If labels in dataset are higher than this number, "rare" label
     :param model_names: List of the names of the models to use as labels.
@@ -2674,7 +2661,7 @@ def calibration_multiclass(
 def confusion_matrix(
         test_stats_per_model,
         metadata,
-        field,
+        output_feature_name,
         top_n_classes,
         normalize,
         model_names=None,
@@ -2682,15 +2669,15 @@ def confusion_matrix(
         file_format='pdf',
         **kwargs
 ):
-    """Show confision matrix in the models predictions for each field.
+    """Show confision matrix in the models predictions for each output_feature_name.
 
     For each model (in the aligned lists of test_statistics and model_names)
     it  produces a heatmap of the confusion matrix in the predictions for
-    each  field that has a confusion matrix in test_statistics. The value of
+    each  output_feature_name that has a confusion matrix in test_statistics. The value of
     top_n_classes limits the heatmap to the n most frequent classes.
     :param test_stats_per_model: List containing train statistics per model
     :param metadata: Model's input metadata
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted and for which is provided ground truth
     :param top_n_classes: List containing the number of classes to plot
     :param normalize: Flag to normalize rows in confusion matrix
     :param model_names: List of the names of the models to use as labels.
@@ -2707,26 +2694,26 @@ def confusion_matrix(
         output_directory,
         filename_template
     )
-    fields = validate_visualization_prediction_field_from_test_stats(
-        field,
+    output_feature_names = _validate_output_feature_name_from_test_stats(
+        output_feature_name,
         test_stats_per_model_list
     )
 
     for i, test_statistics in enumerate(
             test_stats_per_model_list):
-        for field in fields:
-            if 'confusion_matrix' in test_statistics[field]:
+        for output_feature_name in output_feature_names:
+            if 'confusion_matrix' in test_statistics[output_feature_name]:
                 confusion_matrix = np.array(
-                    test_statistics[field]['confusion_matrix']
+                    test_statistics[output_feature_name]['confusion_matrix']
                 )
                 model_name_name = model_names_list[i] if (
                         model_names_list is not None and i < len(
                     model_names_list)
                 ) else ''
 
-                if metadata is not None and field in metadata and 'idx2str' in \
-                        metadata[field]:
-                    labels = metadata[field]['idx2str']
+                if metadata is not None and output_feature_name in metadata and 'idx2str' in \
+                        metadata[output_feature_name]:
+                    labels = metadata[output_feature_name]['idx2str']
                 else:
                     labels = list(range(len(confusion_matrix)))
 
@@ -2747,14 +2734,14 @@ def confusion_matrix(
                         os.makedirs(output_directory, exist_ok=True)
                         filename = filename_template_path.format(
                             model_name_name,
-                            field,
+                            output_feature_name,
                             'top' + str(k)
                         )
 
                     visualization_utils.confusion_matrix_plot(
                         cm,
                         labels[:k],
-                        field=field,
+                        output_feature_name=output_feature_name,
                         filename=filename
                     )
 
@@ -2772,7 +2759,7 @@ def confusion_matrix(
                     if output_directory:
                         filename = filename_template_path.format(
                             'entropy_' + model_name_name,
-                            field,
+                            output_feature_name,
                             'top' + str(k)
                         )
 
@@ -2789,17 +2776,17 @@ def confusion_matrix(
 def frequency_vs_f1(
         test_stats_per_model,
         metadata,
-        field,
+        output_feature_name,
         top_n_classes,
         model_names=None,
         output_directory=None,
         file_format='pdf',
         **kwargs
 ):
-    """Show prediction statistics for the specified field for each model.
+    """Show prediction statistics for the specified output_feature_name for each model.
 
     For each model (in the aligned lists of test_statistics and model_names),
-    produces two plots statistics of predictions for the specified field.
+    produces two plots statistics of predictions for the specified output_feature_name.
 
     The first plot is a line plot with one x axis representing the different
     classes and two vertical axes colored in orange and blue respectively.
@@ -2812,7 +2799,7 @@ def frequency_vs_f1(
      frequency.
     :param test_stats_per_model: List containing train statistics per model
     :param metadata: Model's input metadata
-    :param field: Prediction field containing ground truth.
+    :param output_feature_name: Name of the output feature that is predicted and for which is provided ground truth
     :param top_n_classes: List containing the number of classes to plot
     :param model_names: List of the names of the models to use as labels.
     :param output_directory: Directory where to save plots.
@@ -2828,23 +2815,23 @@ def frequency_vs_f1(
         output_directory,
         filename_template
     )
-    fields = validate_visualization_prediction_field_from_test_stats(
-        field,
+    output_feature_names = _validate_output_feature_name_from_test_stats(
+        output_feature_name,
         test_stats_per_model_list
     )
     k = top_n_classes[0]
 
     for i, test_statistics in enumerate(
             test_stats_per_model_list):
-        for field in fields:
+        for output_feature_name in output_feature_names:
             model_name_name = (model_names_list[i]
                                if model_names_list is not None and i < len(
                 model_names_list)
                                else '')
-            per_class_stats = test_statistics[field]['per_class_stats']
+            per_class_stats = test_statistics[output_feature_name]['per_class_stats']
             f1_scores = []
             labels = []
-            class_names = metadata[field]['idx2str']
+            class_names = metadata[output_feature_name]['idx2str']
             if k > 0:
                 class_names = class_names[:k]
             for class_name in class_names:
@@ -2855,17 +2842,17 @@ def frequency_vs_f1(
             f1_np = np.nan_to_num(np.array(f1_scores, dtype=np.float32))
             f1_sorted_indices = f1_np.argsort()
 
-            field_frequency_dict = {
-                metadata[field]['str2idx'][key]: val
-                for key, val in metadata[field]['str2freq'].items()
+            output_feature_name_frequency_dict = {
+                metadata[output_feature_name]['str2idx'][key]: val
+                for key, val in metadata[output_feature_name]['str2freq'].items()
             }
-            field_frequency_np = np.array(
-                [field_frequency_dict[class_id]
-                 for class_id in sorted(field_frequency_dict)],
+            output_feature_name_frequency_np = np.array(
+                [output_feature_name_frequency_dict[class_id]
+                 for class_id in sorted(output_feature_name_frequency_dict)],
                 dtype=np.int32
             )
 
-            field_frequency_reordered = field_frequency_np[
+            output_feature_name_frequency_reordered = output_feature_name_frequency_np[
                                             f1_sorted_indices[::-1]
                                         ][:len(f1_sorted_indices)]
             f1_reordered = f1_np[f1_sorted_indices[::-1]][
@@ -2874,41 +2861,41 @@ def frequency_vs_f1(
             filename = None
             if output_directory:
                 os.makedirs(output_directory, exist_ok=True)
-                filename = filename_template_path.format(model_name_name, field)
+                filename = filename_template_path.format(model_name_name, output_feature_name)
 
             visualization_utils.double_axis_line_plot(
                 f1_reordered,
-                field_frequency_reordered,
+                output_feature_name_frequency_reordered,
                 'F1 score',
                 'frequency',
                 labels=labels,
                 title='{} F1 Score vs Frequency {}'.format(
                     model_name_name,
-                    field
+                    output_feature_name
                 ),
                 filename=filename
             )
 
-            frequency_sorted_indices = field_frequency_np.argsort()
-            field_frequency_reordered = field_frequency_np[
+            frequency_sorted_indices = output_feature_name_frequency_np.argsort()
+            output_feature_name_frequency_reordered = output_feature_name_frequency_np[
                                             frequency_sorted_indices[::-1]
                                         ][:len(f1_sorted_indices)]
 
-            f1_reordered = np.zeros(len(field_frequency_reordered))
+            f1_reordered = np.zeros(len(output_feature_name_frequency_reordered))
 
             for idx in frequency_sorted_indices[::-1]:
                 if idx < len(f1_np):
                     f1_reordered[idx] = f1_np[idx]
 
             visualization_utils.double_axis_line_plot(
-                field_frequency_reordered,
+                output_feature_name_frequency_reordered,
                 f1_reordered,
                 'frequency',
                 'F1 score',
                 labels=labels,
                 title='{} F1 Score vs Frequency {}'.format(
                     model_name_name,
-                    field
+                    output_feature_name
                 ),
                 filename=filename
             )
@@ -2999,9 +2986,9 @@ def cli(sys_argv):
 
     parser.add_argument(
         '-f',
-        '--field',
+        '--output_feature_name',
         default=[],
-        help='field containing ground truth'
+        help='name of the output feature to visualize'
     )
     parser.add_argument(
         '-gts',
@@ -3011,10 +2998,10 @@ def cli(sys_argv):
     )
     parser.add_argument(
         '-tf',
-        '--threshold_fields',
+        '--threshold_output_feature_names',
         default=[],
         nargs='+',
-        help='fields for 2d threshold'
+        help='names of output features for 2d threshold'
     )
     parser.add_argument(
         '-pred',


Test patch:
diff --git a/tests/integration_tests/test_visualization.py b/tests/integration_tests/test_visualization.py
--- a/tests/integration_tests/test_visualization.py
+++ b/tests/integration_tests/test_visualization.py
@@ -74,20 +74,20 @@ def run_experiment(input_features, output_features, **kwargs):
     return exp_dir_name
 
 
-def get_output_field_name(experiment_dir, output_feature=0):
+def get_output_feature_name(experiment_dir, output_feature=0):
     """Helper function to extract specified output feature name.
 
     :param experiment_dir: Path to the experiment directory
     :param output_feature: position of the output feature the description.json
-    :return field_name: name of the first output feature name
+    :return output_feature_name: name of the first output feature name
                         from the experiment
     """
     description_file = experiment_dir + '/description.json'
     with open(description_file, 'rb') as f:
         content = json.load(f)
-    field_name = \
+    output_feature_name = \
         content['model_definition']['output_features'][output_feature]['name']
-    return field_name
+    return output_feature_name
 
 
 def test_visualisation_learning_curves_output_saved(csv_filename):
@@ -277,8 +277,8 @@ def test_visualisation_compare_classifiers_from_prob_csv_output_saved(
 
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.csv'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.csv'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -288,8 +288,8 @@ def test_visualisation_compare_classifiers_from_prob_csv_output_saved(
                     'compare_classifiers_performance_from_prob',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -344,8 +344,8 @@ def test_visualisation_compare_classifiers_from_prob_npy_output_saved(
 
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -355,8 +355,8 @@ def test_visualisation_compare_classifiers_from_prob_npy_output_saved(
                     'compare_classifiers_performance_from_prob',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -409,8 +409,8 @@ def test_visualisation_compare_classifiers_from_pred_npy_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    prediction = exp_dir_name + '/{}_predictions.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    prediction = exp_dir_name + '/{}_predictions.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -423,8 +423,8 @@ def test_visualisation_compare_classifiers_from_pred_npy_output_saved(
                     ground_truth_metadata,
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--predictions',
                     prediction,
                     prediction,
@@ -477,8 +477,8 @@ def test_visualisation_compare_classifiers_from_pred_csv_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    prediction = exp_dir_name + '/{}_predictions.csv'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    prediction = exp_dir_name + '/{}_predictions.csv'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -491,8 +491,8 @@ def test_visualisation_compare_classifiers_from_pred_csv_output_saved(
                     ground_truth_metadata,
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--predictions',
                     prediction,
                     prediction,
@@ -543,8 +543,8 @@ def test_visualisation_compare_classifiers_subset_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -552,8 +552,8 @@ def test_visualisation_compare_classifiers_subset_output_saved(csv_filename):
                     'ludwig.visualize',
                     '--visualization',
                     'compare_classifiers_performance_subset',
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -606,8 +606,8 @@ def test_visualisation_compare_classifiers_changing_k_output_pdf(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -615,8 +615,8 @@ def test_visualisation_compare_classifiers_changing_k_output_pdf(csv_filename):
                     'ludwig.visualize',
                     '--visualization',
                     'compare_classifiers_performance_changing_k',
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -672,7 +672,7 @@ def test_visualisation_compare_classifiers_multiclass_multimetric_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
     test_stats = exp_dir_name + '/test_statistics.json'
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -681,8 +681,8 @@ def test_visualisation_compare_classifiers_multiclass_multimetric_output_saved(
                     'ludwig.visualize',
                     '--visualization',
                     'compare_classifiers_multiclass_multimetric',
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--test_statistics',
                     test_stats,
                     test_stats,
@@ -735,8 +735,8 @@ def test_visualisation_compare_classifiers_predictions_npy_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    prediction = exp_dir_name + '/{}_predictions.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    prediction = exp_dir_name + '/{}_predictions.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -746,8 +746,8 @@ def test_visualisation_compare_classifiers_predictions_npy_output_saved(
                     'compare_classifiers_predictions',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--predictions',
                     prediction,
                     prediction,
@@ -801,8 +801,8 @@ def test_visualisation_compare_classifiers_predictions_csv_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    prediction = exp_dir_name + '/{}_predictions.csv'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    prediction = exp_dir_name + '/{}_predictions.csv'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -812,8 +812,8 @@ def test_visualisation_compare_classifiers_predictions_csv_output_saved(
                     'compare_classifiers_predictions',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--predictions',
                     prediction,
                     prediction,
@@ -865,8 +865,8 @@ def test_visualisation_cmp_classifiers_predictions_distribution_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    prediction = exp_dir_name + '/{}_predictions.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    prediction = exp_dir_name + '/{}_predictions.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -876,8 +876,8 @@ def test_visualisation_cmp_classifiers_predictions_distribution_output_saved(
                     'compare_classifiers_predictions_distribution',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--predictions',
                     prediction,
                     prediction,
@@ -928,8 +928,8 @@ def test_visualisation_cconfidence_thresholding_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -939,8 +939,8 @@ def test_visualisation_cconfidence_thresholding_output_saved(csv_filename):
                     'confidence_thresholding',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -993,8 +993,8 @@ def test_visualisation_confidence_thresholding_data_vs_acc_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -1004,8 +1004,8 @@ def test_visualisation_confidence_thresholding_data_vs_acc_output_saved(
                     'confidence_thresholding_data_vs_acc',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1058,8 +1058,8 @@ def test_visualisation_confidence_thresholding_data_vs_acc_subset_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -1069,8 +1069,8 @@ def test_visualisation_confidence_thresholding_data_vs_acc_subset_output_saved(
                     'confidence_thresholding_data_vs_acc_subset',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1125,8 +1125,8 @@ def test_vis_confidence_thresholding_data_vs_acc_subset_per_class_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -1139,8 +1139,8 @@ def test_vis_confidence_thresholding_data_vs_acc_subset_per_class_output_saved(
                     ground_truth,
                     '--ground_truth_metadata',
                     ground_truth_metadata,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1202,13 +1202,13 @@ def test_vis_confidence_thresholding_2thresholds_2d_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    treshhold_field1 = get_output_field_name(exp_dir_name)
-    treshhold_field2 = get_output_field_name(exp_dir_name, output_feature=1)
+    treshhold_output_feature_name1 = get_output_feature_name(exp_dir_name)
+    treshhold_output_feature_name2 = get_output_feature_name(exp_dir_name, output_feature=1)
     probability1 = exp_dir_name + '/{}_probabilities.npy'.format(
-        treshhold_field1
+        treshhold_output_feature_name1
     )
     probability2 = exp_dir_name + '/{}_probabilities.npy'.format(
-        treshhold_field2
+        treshhold_output_feature_name2
     )
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
@@ -1222,9 +1222,9 @@ def test_vis_confidence_thresholding_2thresholds_2d_output_saved(
                     '--probabilities',
                     probability1,
                     probability2,
-                    '--threshold_fields',
-                    treshhold_field1,
-                    treshhold_field2,
+                    '--threshold_output_feature_names',
+                    treshhold_output_feature_name1,
+                    treshhold_output_feature_name2,
                     '--model_names',
                     'Model1',
                     '-od', exp_dir_name]
@@ -1278,13 +1278,13 @@ def test_vis_confidence_thresholding_2thresholds_3d_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    treshhold_field1 = get_output_field_name(exp_dir_name)
-    treshhold_field2 = get_output_field_name(exp_dir_name, output_feature=1)
+    treshhold_output_feature_name1 = get_output_feature_name(exp_dir_name)
+    treshhold_output_feature_name2 = get_output_feature_name(exp_dir_name, output_feature=1)
     probability1 = exp_dir_name + '/{}_probabilities.npy'.format(
-        treshhold_field1
+        treshhold_output_feature_name1
     )
     probability2 = exp_dir_name + '/{}_probabilities.npy'.format(
-        treshhold_field2
+        treshhold_output_feature_name2
     )
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
@@ -1298,9 +1298,9 @@ def test_vis_confidence_thresholding_2thresholds_3d_output_saved(csv_filename):
                     '--probabilities',
                     probability1,
                     probability2,
-                    '--threshold_fields',
-                    treshhold_field1,
-                    treshhold_field2,
+                    '--threshold_output_feature_names',
+                    treshhold_output_feature_name1,
+                    treshhold_output_feature_name2,
                     '-od', exp_dir_name]
     test_cmd_png = test_cmd_pdf.copy() + ['-ff', 'png']
 
@@ -1352,8 +1352,8 @@ def test_visualisation_binary_threshold_vs_metric_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -1367,8 +1367,8 @@ def test_visualisation_binary_threshold_vs_metric_output_saved(csv_filename):
                     'accuracy',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1419,8 +1419,8 @@ def test_visualisation_roc_curves_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -1437,8 +1437,8 @@ def test_visualisation_roc_curves_output_saved(csv_filename):
                     ground_truth,
                     '--ground_truth_metadata',
                     ground_truth_metadata,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1487,7 +1487,7 @@ def test_visualisation_roc_curves_from_test_statistics_output_saved(
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
     test_stats = exp_dir_name + '/test_statistics.json'
     experiment_source_data_name = csv_filename.split('.')[0]
     test_cmd_pdf = ['python',
@@ -1495,8 +1495,8 @@ def test_visualisation_roc_curves_from_test_statistics_output_saved(
                     'ludwig.visualize',
                     '--visualization',
                     'roc_curves_from_test_statistics',
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--test_statistics',
                     test_stats,
                     '--model_names',
@@ -1545,8 +1545,8 @@ def test_visualisation_calibration_1_vs_all_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -1558,8 +1558,8 @@ def test_visualisation_calibration_1_vs_all_output_saved(csv_filename):
                     'accuracy',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1612,8 +1612,8 @@ def test_visualisation_calibration_multiclass_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
-    probability = exp_dir_name + '/{}_probabilities.npy'.format(field_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
+    probability = exp_dir_name + '/{}_probabilities.npy'.format(output_feature_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
     test_cmd_pdf = ['python',
@@ -1623,8 +1623,8 @@ def test_visualisation_calibration_multiclass_output_saved(csv_filename):
                     'calibration_multiclass',
                     '--ground_truth',
                     ground_truth,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--probabilities',
                     probability,
                     probability,
@@ -1675,7 +1675,7 @@ def test_visualisation_frequency_vs_f1_output_saved(csv_filename):
     )
     vis_output_pattern_pdf = exp_dir_name + '/*.pdf'
     vis_output_pattern_png = exp_dir_name + '/*.png'
-    field_name = get_output_field_name(exp_dir_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
     test_stats = exp_dir_name + '/test_statistics.json'
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth_metadata = experiment_source_data_name + '.json'
@@ -1686,8 +1686,8 @@ def test_visualisation_frequency_vs_f1_output_saved(csv_filename):
                     'frequency_vs_f1',
                     '--ground_truth_metadata',
                     ground_truth_metadata,
-                    '--field',
-                    field_name,
+                    '--output_feature_name',
+                    output_feature_name,
                     '--test_statistics',
                     test_stats,
                     test_stats,
@@ -1735,32 +1735,32 @@ def test_load_ground_truth_split_from_file(csv_filename):
         output_features,
         data_csv=rel_path
     )
-    field_name = get_output_field_name(exp_dir_name)
+    output_feature_name = get_output_feature_name(exp_dir_name)
     experiment_source_data_name = csv_filename.split('.')[0]
     ground_truth = experiment_source_data_name + '.hdf5'
 
-    ground_truth_train_split = load_from_file(ground_truth, field_name,
+    ground_truth_train_split = load_from_file(ground_truth, output_feature_name,
                                               ground_truth_split=0)
-    ground_truth_val_split = load_from_file(ground_truth, field_name,
+    ground_truth_val_split = load_from_file(ground_truth, output_feature_name,
                                               ground_truth_split=1)
-    ground_truth_test_split = load_from_file(ground_truth, field_name)
+    ground_truth_test_split = load_from_file(ground_truth, output_feature_name)
 
     test_df, train_df, val_df = obtain_df_splits(csv_filename)
-    target_predictions_from_train = train_df[field_name]
-    target_predictions_from_val = val_df[field_name]
-    target_predictions_from_test = test_df[field_name]
+    target_predictions_from_train = train_df[output_feature_name]
+    target_predictions_from_val = val_df[output_feature_name]
+    target_predictions_from_test = test_df[output_feature_name]
     gtm_name = experiment_source_data_name + '.json'
     ground_truth_metadata = load_json(gtm_name)
     ground_truth_loaded_train_split = np.asarray([
-        ground_truth_metadata[field_name]['str2idx'][train_row]
+        ground_truth_metadata[output_feature_name]['str2idx'][train_row]
         for train_row in target_predictions_from_train
     ])
     ground_truth_loaded_val_split = np.asarray([
-        ground_truth_metadata[field_name]['str2idx'][val_row]
+        ground_truth_metadata[output_feature_name]['str2idx'][val_row]
         for val_row in target_predictions_from_val
     ])
     ground_truth_loaded_test_split = np.asarray([
-        ground_truth_metadata[field_name]['str2idx'][test_row]
+        ground_truth_metadata[output_feature_name]['str2idx'][test_row]
         for test_row in target_predictions_from_test
     ])
 
diff --git a/tests/integration_tests/test_visualization_api.py b/tests/integration_tests/test_visualization_api.py
--- a/tests/integration_tests/test_visualization_api.py
+++ b/tests/integration_tests/test_visualization_api.py
@@ -78,20 +78,20 @@ def __init__(self, csv_filename):
         self.test_stats_full = self.model.test(
             data_df=test_df
         )
-        self.field = self.output_features[0]['name']
+        self.output_feature_name = self.output_features[0]['name']
         # probabilities need to be list of lists containing each row data
         # from the probability columns
         # ref: https://uber.github.io/ludwig/api/#test - Return
         self.probability = self.test_stats_full[0].iloc[:, 2:].values
         self.ground_truth_metadata = self.model.train_set_metadata
-        target_predictions = test_df[self.field]
+        target_predictions = test_df[self.output_feature_name]
         self.ground_truth = np.asarray([
-            self.ground_truth_metadata[self.field]['str2idx'][test_row]
+            self.ground_truth_metadata[self.output_feature_name]['str2idx'][test_row]
             for test_row in target_predictions
         ])
         self.prediction_raw = self.test_stats_full[0].iloc[:, 0].tolist()
         self.prediction = np.asarray([
-            self.ground_truth_metadata[self.field]['str2idx'][pred_row]
+            self.ground_truth_metadata[self.output_feature_name]['str2idx'][pred_row]
             for pred_row in self.prediction_raw])
 
     def setup_model(self):
@@ -137,7 +137,7 @@ def test_learning_curves_vis_api(csv_filename):
             viz_output)
         visualize.learning_curves(
             experiment.train_stats,
-            field=None,
+            output_feature_name=None,
             output_directory=experiment.model.exp_dir_name,
             file_format=viz_output
         )
@@ -161,7 +161,7 @@ def test_compare_performance_vis_api(csv_filename):
         )
         visualize.compare_performance(
             [test_stats, test_stats],
-            field=None,
+            output_feature_name=None,
             model_namess=['Model1', 'Model2'],
             output_directory=experiment.model.exp_dir_name,
             file_format=viz_output
@@ -213,7 +213,7 @@ def test_compare_classifier_performance_from_pred_vis_api(csv_filename):
             [prediction, prediction],
             experiment.ground_truth,
             experiment.ground_truth_metadata,
-            experiment.field,
+            experiment.output_feature_name,
             labels_limit=0,
             model_namess=['Model1', 'Model2'],
             output_directory=experiment.model.exp_dir_name,
@@ -294,7 +294,7 @@ def test_compare_classifiers_multiclass_multimetric_vis_api(csv_filename):
         visualize.compare_classifiers_multiclass_multimetric(
             [test_stats, test_stats],
             experiment.ground_truth_metadata,
-            experiment.field,
+            experiment.output_feature_name,
             top_n_classes=[6],
             model_namess=['Model1', 'Model2'],
             output_directory=experiment.model.exp_dir_name,
@@ -456,7 +456,7 @@ def test_confidence_thresholding_data_vs_acc_subset_per_class_vis_api(
             [probability, probability],
             experiment.ground_truth,
             experiment.ground_truth_metadata,
-            experiment.field,
+            experiment.output_feature_name,
             top_n_classes=[3],
             labels_limit=0,
             subset='ground_truth',
@@ -502,22 +502,22 @@ def test_confidence_thresholding_2thresholds_2d_vis_api(csv_filename):
         data_df=test_df
     )
 
-    field1 = output_features[0]['name']
-    field2 = output_features[1]['name']
+    output_feature_name1 = output_features[0]['name']
+    output_feature_name2 = output_features[1]['name']
     # probabilities need to be list of lists containing each row data from the
     # probability columns ref: https://uber.github.io/ludwig/api/#test - Return
     probability1 = test_stats[0].iloc[:, [2, 3, 4]].values
     probability2 = test_stats[0].iloc[:, [7, 8, 9]].values
 
     ground_truth_metadata = model.train_set_metadata
-    target_predictions1 = test_df[field1]
-    target_predictions2 = test_df[field2]
+    target_predictions1 = test_df[output_feature_name1]
+    target_predictions2 = test_df[output_feature_name2]
     ground_truth1 = np.asarray([
-        ground_truth_metadata[field1]['str2idx'][prediction]
+        ground_truth_metadata[output_feature_name1]['str2idx'][prediction]
         for prediction in target_predictions1
     ])
     ground_truth2 = np.asarray([
-        ground_truth_metadata[field2]['str2idx'][prediction]
+        ground_truth_metadata[output_feature_name2]['str2idx'][prediction]
         for prediction in target_predictions2
     ])
     viz_outputs = ('pdf', 'png')
@@ -526,7 +526,7 @@ def test_confidence_thresholding_2thresholds_2d_vis_api(csv_filename):
         visualize.confidence_thresholding_2thresholds_2d(
             [probability1, probability2],
             [ground_truth1, ground_truth2],
-            [field1, field2],
+            [output_feature_name1, output_feature_name2],
             labels_limit=0,
             model_names=['Model1'],
             output_directory=model.exp_dir_name,
@@ -568,22 +568,22 @@ def test_confidence_thresholding_2thresholds_3d_vis_api(csv_filename):
         data_df=test_df
     )
 
-    field1 = output_features[0]['name']
-    field2 = output_features[1]['name']
+    output_feature_name1 = output_features[0]['name']
+    output_feature_name2 = output_features[1]['name']
     # probabilities need to be list of lists containing each row data from the
     # probability columns ref: https://uber.github.io/ludwig/api/#test - Return
     probability1 = test_stats[0].iloc[:, [2, 3, 4]].values
     probability2 = test_stats[0].iloc[:, [7, 8, 9]].values
 
     ground_truth_metadata = model.train_set_metadata
-    target_predictions1 = test_df[field1]
-    target_predictions2 = test_df[field2]
+    target_predictions1 = test_df[output_feature_name1]
+    target_predictions2 = test_df[output_feature_name2]
     ground_truth1 = np.asarray([
-        ground_truth_metadata[field1]['str2idx'][prediction]
+        ground_truth_metadata[output_feature_name1]['str2idx'][prediction]
         for prediction in target_predictions1
     ])
     ground_truth2 = np.asarray([
-        ground_truth_metadata[field2]['str2idx'][prediction]
+        ground_truth_metadata[output_feature_name2]['str2idx'][prediction]
         for prediction in target_predictions2
     ])
     viz_outputs = ('pdf', 'png')
@@ -592,7 +592,7 @@ def test_confidence_thresholding_2thresholds_3d_vis_api(csv_filename):
         visualize.confidence_thresholding_2thresholds_3d(
             [probability1, probability2],
             [ground_truth1, ground_truth2],
-            [field1, field2],
+            [output_feature_name1, output_feature_name2],
             labels_limit=0,
             output_directory=model.exp_dir_name,
             file_format=viz_output
@@ -670,7 +670,7 @@ def test_roc_curves_from_test_statistics_vis_api(csv_filename):
 
     # Generate test data
     data_csv = generate_data(input_features, output_features, csv_filename)
-    field = output_features[0]['name']
+    output_feature_name = output_features[0]['name']
     input_features[0]['encoder'] = encoder
     model = run_api_experiment(input_features, output_features)
     data_df = read_csv(data_csv)
@@ -681,7 +681,7 @@ def test_roc_curves_from_test_statistics_vis_api(csv_filename):
         vis_output_pattern_pdf = model.exp_dir_name + '/*.{}'.format(viz_output)
         visualize.roc_curves_from_test_statistics(
             [test_stats, test_stats],
-            field,
+            output_feature_name,
             model_namess=['Model1', 'Model2'],
             output_directory=model.exp_dir_name,
             file_format=viz_output
@@ -760,7 +760,7 @@ def test_confusion_matrix_vis_api(csv_filename):
         visualize.confusion_matrix(
             [test_stats, test_stats],
             experiment.ground_truth_metadata,
-            experiment.field,
+            experiment.output_feature_name,
             top_n_classes=[0],
             normalize=False,
             model_names=['Model1', 'Model2'],
@@ -788,7 +788,7 @@ def test_frequency_vs_f1_vis_api(csv_filename):
         visualize.frequency_vs_f1(
             [test_stats, test_stats],
             experiment.ground_truth_metadata,
-            experiment.field,
+            experiment.output_feature_name,
             top_n_classes=[0],
             model_names=['Model1', 'Model2'],
             output_directory=experiment.model.exp_dir_name,