coco_pipe.viz.interactive.decoding ================================== .. py:module:: coco_pipe.viz.interactive.decoding .. autoapi-nested-parse:: Interactive Plotly visualization helpers for decoding result tables. Functions --------- .. autoapisummary:: coco_pipe.viz.interactive.decoding.plot_confusion_matrix coco_pipe.viz.interactive.decoding.plot_roc_curve coco_pipe.viz.interactive.decoding.plot_pr_curve coco_pipe.viz.interactive.decoding.plot_calibration_curve coco_pipe.viz.interactive.decoding.plot_fold_score_dispersion coco_pipe.viz.interactive.decoding.plot_temporal_score_curve coco_pipe.viz.interactive.decoding.plot_temporal_generalization_matrix coco_pipe.viz.interactive.decoding.plot_temporal_statistical_assessment coco_pipe.viz.interactive.decoding.plot_null_interval_summary coco_pipe.viz.interactive.decoding.plot_training_history coco_pipe.viz.interactive.decoding.plot_decoding_scores coco_pipe.viz.interactive.decoding.plot_model_comparison coco_pipe.viz.interactive.decoding.plot_fit_diagnostics coco_pipe.viz.interactive.decoding.plot_probability_diagnostics coco_pipe.viz.interactive.decoding.plot_subject_diagnostics coco_pipe.viz.interactive.decoding.plot_group_summary coco_pipe.viz.interactive.decoding.plot_regression_diagnostics coco_pipe.viz.interactive.decoding.plot_search_results coco_pipe.viz.interactive.decoding.plot_feature_stability coco_pipe.viz.interactive.decoding.plot_feature_scores coco_pipe.viz.interactive.decoding.plot_feature_importance Module Contents --------------- .. py:function:: plot_confusion_matrix(result_or_matrix, model = None, fold = None, title = None) Plot an aggregated confusion matrix interactively. :param result_or_matrix: Experiment result with ``get_confusion_matrices()`` or a tidy DataFrame containing ``TrueLabel``, ``PredictedLabel``, and ``Value``. :param model: Optional model name used to filter rows before aggregation. :param fold: Optional fold index used to filter rows before aggregation. :param title: Optional figure title. Defaults to ``"Confusion Matrix"``. :returns: Interactive confusion matrix heatmap. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_confusion_matrix` Static Matplotlib version. :py:obj:`plot_probability_diagnostics` Probability quality diagnostics for classifier output. :py:obj:`plot_calibration_curve` Calibration reliability curve for probability estimates. :py:obj:`plot_roc_curve` ROC curve complementing confusion matrix analysis. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "TrueLabel": ["A", "B", "A"], ... "PredictedLabel": ["A", "B", "B"], ... "Value": [5, 3, 2], ... } ... ) >>> fig = viz.plot_confusion_matrix(df) .. py:function:: plot_roc_curve(result_or_curve, model = None, fold = None, title = None, mean_only = False) Plot receiver-operating-characteristic curves interactively. :param result_or_curve: Experiment result with ``get_roc_curve()`` or a DataFrame containing ``Model``, ``FPR``, and ``TPR``. :param model: Optional model name to display. :param fold: Optional fold index to display. :param title: Optional figure title. Defaults to ``"ROC Curve"``. :param mean_only: If True, interpolate fold curves onto a common grid and draw the mean curve with a standard-deviation band. :returns: Interactive ROC curve figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_roc_curve` Static Matplotlib version. :py:obj:`plot_pr_curve` Precision-recall curve for imbalanced-class problems. :py:obj:`plot_calibration_curve` Calibration reliability curve. :py:obj:`plot_confusion_matrix` Confusion matrix at a fixed operating point. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"Model": ["SVM", "SVM"], "FPR": [0.0, 1.0], "TPR": [0.0, 1.0]} ... ) >>> fig = viz.plot_roc_curve(df) .. py:function:: plot_pr_curve(result_or_curve, model = None, fold = None, title = None, mean_only = False) Plot precision-recall curves interactively. :param result_or_curve: Experiment result with ``get_pr_curve()`` or a DataFrame containing ``Model``, ``Recall``, and ``Precision``. :param model: Optional model name to display. :param fold: Optional fold index to display. :param title: Optional figure title. Defaults to ``"Precision-Recall Curve"``. :param mean_only: If True, draw the mean curve with a standard-deviation band. :returns: Interactive precision-recall curve figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_pr_curve` Static Matplotlib version. :py:obj:`plot_roc_curve` ROC curve for alternative threshold analysis. :py:obj:`plot_calibration_curve` Calibration reliability curve. :py:obj:`plot_fold_score_dispersion` Fold-level score variability. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"Model": ["SVM", "SVM"], "Recall": [0.0, 1.0], "Precision": [1.0, 0.5]} ... ) >>> fig = viz.plot_pr_curve(df) .. py:function:: plot_calibration_curve(result_or_curve, model = None, fold = None, title = None, mean_only = False) Plot calibration reliability curves interactively. :param result_or_curve: Experiment result with ``get_calibration_curve()`` or a DataFrame containing ``Model``, ``MeanPredictedProbability``, and ``FractionPositive``. :param model: Optional model name to display. :param fold: Optional fold index to display. :param title: Optional figure title. Defaults to ``"Calibration Curve"``. :param mean_only: If True, draw the mean curve with a standard-deviation band. :returns: Interactive calibration curve figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_calibration_curve` Static Matplotlib version. :py:obj:`plot_roc_curve` ROC curve complementing calibration analysis. :py:obj:`plot_pr_curve` Precision-recall curve for classifier evaluation. :py:obj:`plot_probability_diagnostics` Scalar probability-quality metrics. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["LR", "LR"], ... "MeanPredictedProbability": [0.2, 0.8], ... "FractionPositive": [0.15, 0.85], ... } ... ) >>> fig = viz.plot_calibration_curve(df) .. py:function:: plot_fold_score_dispersion(result_or_scores, metric = None, model = None, title = None) Plot fold-level scalar score distributions by model and metric interactively. :param result_or_scores: Experiment result with ``get_detailed_scores()`` or a detailed score DataFrame containing scalar ``Value`` rows. :param metric: Optional metric name used to filter scores. :param model: Optional model name used to filter scores. :param title: Optional figure title. Defaults to ``"Fold Score Dispersion"``. :returns: Interactive fold score box plot. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_fold_score_dispersion` Static Matplotlib version. :py:obj:`plot_decoding_scores` Aggregate score bar chart with error bars. :py:obj:`plot_model_comparison` Pairwise score-difference comparison. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 4, ... "Fold": [0, 1, 2, 3], ... "Metric": ["accuracy"] * 4, ... "Value": [0.8, 0.85, 0.82, 0.78], ... } ... ) >>> fig = viz.plot_fold_score_dispersion(df) .. py:function:: plot_temporal_score_curve(result_or_scores, metric = None, model = None, title = None, colors = None, smooth_window = None) Plot mean temporal decoding score curves interactively. :param result_or_scores: Experiment result with ``get_temporal_score_summary()`` or a DataFrame containing ``Model``, ``Metric``, ``Time``, and ``Mean``. :param metric: Optional metric name used to filter temporal scores. :param model: Optional model name used to filter temporal scores. :param title: Optional figure title. Defaults to ``"Temporal Decoding Value"``. :param colors: Optional dict mapping model names to CSS color strings. :param smooth_window: Optional integer window size for smoothing the curves using a centered moving average. :returns: Interactive temporal score curve figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_temporal_score_curve` Static Matplotlib version. :py:obj:`plot_temporal_generalization_matrix` Train-time by test-time generalization matrix. :py:obj:`plot_temporal_statistical_assessment` Statistical significance overlay on temporal curves. :py:obj:`plot_null_interval_summary` Null permutation interval for scalar score comparison. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 3, ... "Metric": ["accuracy"] * 3, ... "Time": [0.1, 0.2, 0.3], ... "Mean": [0.6, 0.75, 0.7], ... } ... ) >>> fig = viz.plot_temporal_score_curve(df) .. py:function:: plot_temporal_generalization_matrix(result_or_scores, metric = None, model = None, title = None) Plot a train-time by test-time temporal generalization matrix interactively. :param result_or_scores: Experiment result with ``get_temporal_score_summary()`` or a DataFrame containing ``Model``, ``Metric``, ``TrainTime``, ``TestTime``, and ``Mean``. :param metric: Optional metric name. :param model: Optional model name. :param title: Optional figure title. Defaults to ``" / "``. :returns: Interactive generalization matrix heatmap. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_temporal_generalization_matrix` Static Matplotlib version. :py:obj:`plot_temporal_score_curve` Mean temporal score curve across time. :py:obj:`plot_temporal_statistical_assessment` Statistical assessment of temporal decoding. :py:obj:`plot_null_interval_summary` Null permutation interval summary. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 4, ... "Metric": ["accuracy"] * 4, ... "TrainTime": [0.1, 0.1, 0.2, 0.2], ... "TestTime": [0.1, 0.2, 0.1, 0.2], ... "Mean": [0.8, 0.6, 0.65, 0.82], ... } ... ) >>> fig = viz.plot_temporal_generalization_matrix(df) .. py:function:: plot_temporal_statistical_assessment(result_or_assessment, metric = None, model = None, title = None) Plot temporal statistical assessment results interactively. :param result_or_assessment: Experiment result with ``get_statistical_assessment()`` or a DataFrame containing ``Model``, ``Metric``, ``Observed``, and ``Time``. :param metric: Optional metric name. :param model: Optional model name. :param title: Optional figure title. :returns: Interactive temporal statistical assessment figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_temporal_statistical_assessment` Static Matplotlib version. :py:obj:`plot_temporal_score_curve` Mean temporal decoding score curve. :py:obj:`plot_null_interval_summary` Scalar null interval summary across models. :py:obj:`plot_temporal_generalization_matrix` Full train-by-test generalization matrix. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 3, ... "Metric": ["accuracy"] * 3, ... "Observed": [0.6, 0.75, 0.7], ... "Time": [0.1, 0.2, 0.3], ... } ... ) >>> fig = viz.plot_temporal_statistical_assessment(df) .. py:function:: plot_null_interval_summary(result_or_assessment, metric = None, model = None, title = None) Plot observed scalar scores against null interval summaries interactively. :param result_or_assessment: Experiment result with ``get_statistical_assessment()`` or a DataFrame containing ``Model``, ``Metric``, and ``Observed``. :param metric: Optional metric name used to filter assessment rows. :param model: Optional model name used to filter assessment rows. :param title: Optional figure title. Defaults to ``"Null Interval Summary"``. :returns: Interactive null interval summary figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_null_interval_summary` Static Matplotlib version. :py:obj:`plot_temporal_statistical_assessment` Temporal null band overlaid on the score curve. :py:obj:`plot_temporal_score_curve` Mean temporal decoding score curve. :py:obj:`plot_decoding_scores` Aggregate score bar chart without null bands. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM", "LDA"], ... "Metric": ["accuracy", "accuracy"], ... "Observed": [0.82, 0.74], ... } ... ) >>> fig = viz.plot_null_interval_summary(df) .. py:function:: plot_training_history(result_or_artifacts, model = None, title = None) Plot neural training-history artifacts interactively. :param result_or_artifacts: Experiment result with ``get_model_artifacts()`` or an artifact DataFrame containing ``Model``, ``Key``, ``ArtifactType``, and ``Value``. :param model: Optional model name used to filter artifacts. :param title: Optional figure title. Defaults to ``"Training History"``. :returns: Interactive training history line chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_training_history` Static Matplotlib version. :py:obj:`plot_fit_diagnostics` Fit-time diagnostics including total training time. :py:obj:`plot_decoding_scores` Final evaluation scores after training. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["CNN"], ... "Key": ["training"], ... "ArtifactType": ["history"], ... "Value": [[{"epoch": 0, "loss": 1.0}, {"epoch": 1, "loss": 0.5}]], ... } ... ) >>> fig = viz.plot_training_history(df) .. py:function:: plot_decoding_scores(result, metric = None, model = None, aggregate = 'mean', title = None) Plot aggregate scalar decoding scores by model and metric interactively. :param result: Experiment result with ``get_detailed_scores()`` or a detailed score DataFrame containing scalar ``Value`` rows. :param metric: Optional metric name used to filter scores. :param model: Optional model name used to filter scores. :param aggregate: Summary statistic: ``"mean"`` or ``"median"``. :param title: Optional figure title. Defaults to ``"Decoding Scores"``. :returns: Interactive decoding score bar chart with error bars. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_decoding_scores` Static Matplotlib version. :py:obj:`plot_fold_score_dispersion` Per-fold score distribution box plot. :py:obj:`plot_model_comparison` Pairwise model score-difference figure. :py:obj:`plot_null_interval_summary` Observed scores against null permutation intervals. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 3, ... "Fold": [0, 1, 2], ... "Metric": ["accuracy"] * 3, ... "Value": [0.8, 0.85, 0.82], ... } ... ) >>> fig = viz.plot_decoding_scores(df) .. py:function:: plot_model_comparison(result, metric = 'accuracy', reference = None, paired = True, title = None) Plot model-comparison score differences interactively. :param result: Experiment result or a comparison DataFrame with a ``Difference`` column. Optional ``ModelA``, ``ModelB``, ``CILower``, ``CIUpper`` columns are also used when present. :param metric: Metric used when computing comparisons. :param reference: Optional reference model for paired comparisons. :param paired: If True and ``reference`` is provided, use ``compare_models_paired``. :param title: Optional figure title. :returns: Interactive model comparison scatter figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_model_comparison` Static Matplotlib version. :py:obj:`plot_decoding_scores` Aggregate score bar chart per model. :py:obj:`plot_fold_score_dispersion` Per-fold score variability. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame({"Difference": [0.05, -0.02, 0.08]}) >>> fig = viz.plot_model_comparison(df) .. py:function:: plot_fit_diagnostics(result, by = 'Model', show_warnings = True, title = None) Plot fit-time diagnostics by model or fold interactively. :param result: Experiment result with ``get_fit_diagnostics()`` or a diagnostics DataFrame containing ``TotalTime`` plus the selected ``by`` column. :param by: Column used for grouping, usually ``"Model"`` or ``"Fold"``. :param show_warnings: If True, annotate the figure with the warning count when present. :param title: Optional figure title. Defaults to ``"Fit Diagnostics"``. :returns: Interactive fit diagnostics bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_fit_diagnostics` Static Matplotlib version. :py:obj:`plot_training_history` Epoch-level training metrics for neural models. :py:obj:`plot_search_results` Hyperparameter-search results sorted by rank. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"Model": ["SVM", "LDA"], "Fold": [0, 0], "TotalTime": [1.2, 0.4]} ... ) >>> fig = viz.plot_fit_diagnostics(df) .. py:function:: plot_probability_diagnostics(result, model = None, metric = None, title = None) Plot probability-quality diagnostics interactively. :param result: Experiment result with ``get_probability_diagnostics()`` or a DataFrame containing ``Model``, ``Metric``, and ``Value``. :param model: Optional model name used to filter diagnostics. :param metric: Optional diagnostic metric used to filter rows. :param title: Optional figure title. Defaults to ``"Probability Diagnostics"``. :returns: Interactive probability diagnostics bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_probability_diagnostics` Static Matplotlib version. :py:obj:`plot_confusion_matrix` Confusion matrix for a complementary classifier view. :py:obj:`plot_calibration_curve` Reliability curve for probability estimates. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["LR", "LR"], ... "Metric": ["brier_score", "log_loss"], ... "Value": [0.12, 0.35], ... } ... ) >>> fig = viz.plot_probability_diagnostics(df) .. py:function:: plot_subject_diagnostics(result, unit = 'Subject', metric = 'accuracy', model = None, title = None) Plot per-unit prediction accuracy diagnostics interactively. :param result: Experiment result with ``get_predictions()`` or a prediction DataFrame containing ``Model``, ``y_true``, ``y_pred``, and the selected ``unit`` column. :param unit: Metadata column used as the unit of aggregation. :param metric: Metric to compute. Currently only ``"accuracy"`` is supported. :param model: Optional model name used to filter predictions. :param title: Optional figure title. Defaults to ``" Diagnostics"``. :returns: Interactive subject diagnostics horizontal bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_subject_diagnostics` Static Matplotlib version. :py:obj:`plot_group_summary` Group-level accuracy summary with fold-level box plots. :py:obj:`plot_regression_diagnostics` Observed vs predicted scatter for regression models. :py:obj:`plot_fit_diagnostics` Per-model or per-fold timing diagnostics. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 4, ... "Subject": ["S1", "S1", "S2", "S2"], ... "y_true": ["A", "B", "A", "B"], ... "y_pred": ["A", "B", "A", "A"], ... } ... ) >>> fig = viz.plot_subject_diagnostics(df) .. py:function:: plot_group_summary(result, group = 'Group', metric = 'accuracy', model = None, title = None) Plot group-level prediction accuracy summaries interactively. :param result: Experiment result with ``get_predictions()`` or a prediction DataFrame containing ``Model``, ``Fold``, ``y_true``, ``y_pred``, and the selected grouping column. :param group: Prediction metadata column used to define groups. :param metric: Metric to compute. Currently only ``"accuracy"`` is supported. :param model: Optional model name used to filter predictions. :param title: Optional figure title. Defaults to ``"Group Summary"``. :returns: Interactive group summary box plot. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_group_summary` Static Matplotlib version. :py:obj:`plot_subject_diagnostics` Per-subject accuracy horizontal bar chart. :py:obj:`plot_regression_diagnostics` Observed vs predicted for regression outputs. :py:obj:`plot_fold_score_dispersion` Fold-level score variability per model. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 4, ... "Group": ["G1", "G1", "G2", "G2"], ... "Fold": [0, 1, 0, 1], ... "y_true": ["A", "B", "A", "B"], ... "y_pred": ["A", "A", "A", "B"], ... } ... ) >>> fig = viz.plot_group_summary(df) .. py:function:: plot_regression_diagnostics(result, model = None, fold = None, title = None) Plot regression prediction diagnostics interactively. :param result: Experiment result with ``get_predictions()`` or a prediction DataFrame containing numeric ``y_true`` and ``y_pred`` columns. :param model: Optional model name used to filter predictions. :param fold: Optional fold index used to filter predictions. :param title: Optional figure title. Defaults to ``"Regression Diagnostics"``. :returns: Interactive observed vs predicted scatter figure. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_regression_diagnostics` Static Matplotlib version. :py:obj:`plot_subject_diagnostics` Per-subject accuracy for classification models. :py:obj:`plot_group_summary` Group-level accuracy with fold-level variability. :py:obj:`plot_fit_diagnostics` Fit-time and warning diagnostics. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"y_true": [1.0, 2.0, 3.0, 4.0], "y_pred": [1.1, 1.9, 3.2, 3.8]} ... ) >>> fig = viz.plot_regression_diagnostics(df) .. py:function:: plot_search_results(result, model = None, top_n = None, title = None) Plot compact hyperparameter-search results interactively. :param result: Experiment result with ``get_search_results()`` or a search-results DataFrame containing ``Model``, ``Rank``, and ``MeanTestScore``. :param model: Optional model name used to filter search rows. :param top_n: Optional positive number of top-ranked candidates to keep per model. :param title: Optional figure title. Defaults to ``"Search Results"``. :returns: Interactive search results bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_search_results` Static Matplotlib version. :py:obj:`plot_fit_diagnostics` Fit-time diagnostics complementing search analysis. :py:obj:`plot_decoding_scores` Final evaluation scores after hyperparameter selection. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 3, ... "Rank": [1, 2, 3], ... "MeanTestScore": [0.88, 0.85, 0.82], ... } ... ) >>> fig = viz.plot_search_results(df) .. py:function:: plot_feature_stability(result, model = None, top_n = 25, title = None) Plot feature-selection stability interactively. :param result: Experiment result with ``get_feature_stability()`` or a DataFrame containing ``FeatureName`` and ``SelectionFrequency``. :param model: Optional model name used to filter feature rows. :param top_n: Optional number of most stable features to display. :param title: Optional figure title. Defaults to ``"Feature Stability"``. :returns: Interactive feature stability horizontal bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_feature_stability` Static Matplotlib version. :py:obj:`plot_feature_scores` Univariate feature-selector scores. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"FeatureName": ["F1", "F2", "F3"], "SelectionFrequency": [0.9, 0.6, 0.3]} ... ) >>> fig = viz.plot_feature_stability(df) .. py:function:: plot_feature_scores(result, model = None, top_n = 25, title = None) Plot univariate feature-selector scores interactively. :param result: Experiment result with ``get_feature_scores()`` or a feature-score DataFrame containing ``FeatureName`` and ``Score``. :param model: Optional model name used to filter feature scores. :param top_n: Optional positive number of highest-scoring features to display. :param title: Optional figure title. Defaults to ``"Feature Scores"``. :returns: Interactive feature scores horizontal bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_feature_scores` Static Matplotlib version. :py:obj:`plot_feature_stability` Feature-selection stability across folds. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... {"FeatureName": ["F1", "F2", "F3"], "Score": [0.72, 0.55, 0.31]} ... ) >>> fig = viz.plot_feature_scores(df) .. py:function:: plot_feature_importance(result, model = None, top_n = 25, signed = False, absolute = False, title = None) Plot ranked feature importances interactively. :param result: Experiment result with ``get_feature_importances()``, a feature importance DataFrame, or a mapping/sequence coercible to a numeric Series. Non-numeric sequences are delegated to the dimensionality reduction feature-importance plot. :param model: Optional model name used to filter importances. :param top_n: Optional number of highest-magnitude features to display. :param signed: If True, color bars by sign (diverging) instead of a single color. :param absolute: If True, rank and display absolute importance values. :param title: Optional figure title. Defaults to ``"Feature Importance"``. :returns: Interactive feature-importance horizontal bar chart. :rtype: plotly.graph_objects.Figure .. seealso:: :py:obj:`coco_pipe.viz.decoding.plot_feature_importance` Static Matplotlib version. :py:obj:`plot_feature_stability` Feature-selection stability across folds. :py:obj:`plot_feature_scores` Univariate feature-selector scores. .. rubric:: Examples >>> import pandas as pd >>> from coco_pipe.viz.interactive import decoding as viz >>> df = pd.DataFrame( ... { ... "Model": ["SVM"] * 3, ... "FeatureName": ["f1", "f2", "f3"], ... "Mean": [0.5, 0.3, 0.1], ... } ... ) >>> fig = viz.plot_feature_importance(df)