Skip to content

Drift Configuration

All models that create a DriftProfile will require a DriftConfig object. This object is used to configure the drift detection algorithm and alerting system.

The DriftConfig object has the following structure:

{"name": "model",
 "repository": "scouter",
 "version": "0.1.0",
 "sample_size": 100,
 "sample": true,
 "alert_config": {
     "alert_rule": {
         "process_rule": {"rule": "16 32 4 8 2 4 1 1"}
     },
     "alert_dispatch_type": "Console",
     "schedule": "0 0 0 0 0"
 }
}

Arguments

name
The name of the model or dataset you are monitoring.
repository
The repository where the model or dataset is stored.
version
The version of the model or dataset you are monitoring.
sample
Whether to sample the data or not. Defaults to True.
sample_size
The size of the sample to take. Defaults to 25.
schedule
The 6 digit cron schedule for monitoring. Defaults to "0 0 0 * * *".
alert_rule
The alert rule to use for monitoring. Defaults to the 8 digit rule. See Alerting for more information.
alert_dispatch_type
The type of alerting to use. Defaults to AlertDispatchType.Console. See Alerting for more information.

Scheduling

The drift configuration uses a 6 digit cron to schedule monitoring via the scouter-server.

<second> <minute> <hour> <day of month> <month> <day of week>

The default value is 0 0 0 * * * which means to run every day at midnight (UTC).

Scouter also includes a few helper classes to that provide common scheduling patterns. These are:

  • Every30Minutes
  • EveryHour
  • Every6Hours
  • Every12Hours
  • EveryDay
  • EveryWeek
from scouter import SpcDriftConfig, EveryDay, CommonCrons


# Recommended way to set the schedule
config = SpcDriftConfig(
    name="model",
    repository="scouter",
    version="0.1.0",
    schedule=CommonCrons.EVERY_DAY
)

# This will also work
config = SpcDriftConfig(
    name="model",
    repository="scouter",
    version="0.1.0",
    schedule=EveryDay().cron
)


# or your own
config = SpcDriftConfig(
    name="model",
    repository="scouter",
    version="0.1.0",
    schedule="0 0 0 * * *"
)

scouter._scouter.SpcDriftConfig

Source code in scouter/_scouter.pyi 
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
class SpcDriftConfig:
    def __init__(
        self,
        repository: Optional[str] = None,
        name: Optional[str] = None,
        version: Optional[str] = None,
        sample: bool = True,
        sample_size: int = 25,
        alert_config: Optional[SpcAlertConfig] = None,
        feature_map: Optional[FeatureMap] = None,
        targets: Optional[List[str]] = None,
        config_path: Optional[Path] = None,
    ):
        """Initialize monitor config

        Args:
            repository:
                Model repository
            name:
                Model name
            version:
                Model version. Defaults to 0.1.0
            sample:
                Whether to sample or not
            sample_size:
                Sample size
            feature_map:
                Feature map
            targets:
                List of features that are targets in your dataset.
                This is typically the name of your dependent variable(s).
                This primarily used for monitoring and UI purposes.
            alert_config:
                Alert configuration
            config_path:
                Optional path to load config from.
        """

    @property
    def sample_size(self) -> int:
        """Return the sample size."""

    @sample_size.setter
    def sample_size(self, sample_size: int) -> None:
        """Set the sample size."""

    @property
    def sample(self) -> bool:
        """Whether to sample or not"""

    @sample.setter
    def sample(self, sample: bool) -> None:
        """Set whether to sample or not"""

    @property
    def name(self) -> str:
        """Model Name"""

    @name.setter
    def name(self, name: str) -> None:
        """Set model name"""

    @property
    def repository(self) -> str:
        """Model repository"""

    @repository.setter
    def repository(self, repository: str) -> None:
        """Set model repository"""

    @property
    def version(self) -> str:
        """Model version"""

    @version.setter
    def version(self, version: str) -> None:
        """Set model version"""

    @property
    def feature_map(self) -> Optional[FeatureMap]:
        """Feature map"""

    @feature_map.setter
    def feature_map(self, feature_map: FeatureMap) -> None:
        """Set feature map"""

    @property
    def targets(self) -> List[str]:
        """List of target features to monitor"""

    @targets.setter
    def targets(self, targets: List[str]) -> None:
        """Set list of target features to monitor"""

    @property
    def alert_config(self) -> SpcAlertConfig:
        """Alert configuration"""

    @alert_config.setter
    def alert_config(self, alert_config: SpcAlertConfig) -> None:
        """Set alert configuration"""

    @property
    def drift_type(self) -> DriftType:
        """Drift type"""

    def update_feature_map(self, feature_map: FeatureMap) -> None:
        """Update feature map"""

    @staticmethod
    def load_from_json_file(path: Path) -> "SpcDriftConfig":
        """Load config from json file

        Args:
            path:
                Path to json file to load config from.
        """

    def __str__(self) -> str:
        """Return the string representation of the config."""

    def model_dump_json(self) -> str:
        """Return the json representation of the config."""

    def update_config_args(
        self,
        repository: Optional[str] = None,
        name: Optional[str] = None,
        version: Optional[str] = None,
        sample: Optional[bool] = None,
        sample_size: Optional[int] = None,
        feature_map: Optional[FeatureMap] = None,
        targets: Optional[List[str]] = None,
        alert_config: Optional[SpcAlertConfig] = None,
    ) -> None:
        """Inplace operation that updates config args

        Args:
            repository:
                Model repository
            name:
                Model name
            version:
                Model version
            sample:
                Whether to sample or not
            sample_size:
                Sample size
            feature_map:
                Feature map
            targets:
                List of features that are targets in your dataset.
                This is typically the name of your dependent variable(s).
                This primarily used for monitoring and UI purposes.
            alert_config:
                Alert configuration
        """

alert_config: SpcAlertConfig property writable

Alert configuration

drift_type: DriftType property

Drift type

feature_map: Optional[FeatureMap] property writable

Feature map

name: str property writable

Model Name

repository: str property writable

Model repository

sample: bool property writable

Whether to sample or not

sample_size: int property writable

Return the sample size.

targets: List[str] property writable

List of target features to monitor

version: str property writable

Model version

__init__(repository=None, name=None, version=None, sample=True, sample_size=25, alert_config=None, feature_map=None, targets=None, config_path=None)

Initialize monitor config

Parameters:

Name Type Description Default
repository Optional[str]

Model repository

 None
name Optional[str]

Model name

 None
version Optional[str]

Model version. Defaults to 0.1.0

 None
sample bool

Whether to sample or not

 True
sample_size int

Sample size

 25
feature_map Optional[FeatureMap]

Feature map

 None
targets Optional[List[str]]

List of features that are targets in your dataset. This is typically the name of your dependent variable(s). This primarily used for monitoring and UI purposes.

 None
alert_config Optional[SpcAlertConfig]

Alert configuration

 None
config_path Optional[Path]

Optional path to load config from.

 None
Source code in scouter/_scouter.pyi 
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
def __init__(
    self,
    repository: Optional[str] = None,
    name: Optional[str] = None,
    version: Optional[str] = None,
    sample: bool = True,
    sample_size: int = 25,
    alert_config: Optional[SpcAlertConfig] = None,
    feature_map: Optional[FeatureMap] = None,
    targets: Optional[List[str]] = None,
    config_path: Optional[Path] = None,
):
    """Initialize monitor config

    Args:
        repository:
            Model repository
        name:
            Model name
        version:
            Model version. Defaults to 0.1.0
        sample:
            Whether to sample or not
        sample_size:
            Sample size
        feature_map:
            Feature map
        targets:
            List of features that are targets in your dataset.
            This is typically the name of your dependent variable(s).
            This primarily used for monitoring and UI purposes.
        alert_config:
            Alert configuration
        config_path:
            Optional path to load config from.
    """

__str__()

Return the string representation of the config.

Source code in scouter/_scouter.pyi 
758
759
def __str__(self) -> str:
    """Return the string representation of the config."""

load_from_json_file(path) staticmethod

Load config from json file

Parameters:

Name Type Description Default
path Path

Path to json file to load config from.

 required
Source code in scouter/_scouter.pyi 
749
750
751
752
753
754
755
756
@staticmethod
def load_from_json_file(path: Path) -> "SpcDriftConfig":
    """Load config from json file

    Args:
        path:
            Path to json file to load config from.
    """

model_dump_json()

Return the json representation of the config.

Source code in scouter/_scouter.pyi 
761
762
def model_dump_json(self) -> str:
    """Return the json representation of the config."""

update_config_args(repository=None, name=None, version=None, sample=None, sample_size=None, feature_map=None, targets=None, alert_config=None)

Inplace operation that updates config args

Parameters:

Name Type Description Default
repository Optional[str]

Model repository

 None
name Optional[str]

Model name

 None
version Optional[str]

Model version

 None
sample Optional[bool]

Whether to sample or not

 None
sample_size Optional[int]

Sample size

 None
feature_map Optional[FeatureMap]

Feature map

 None
targets Optional[List[str]]

List of features that are targets in your dataset. This is typically the name of your dependent variable(s). This primarily used for monitoring and UI purposes.

 None
alert_config Optional[SpcAlertConfig]

Alert configuration

 None
Source code in scouter/_scouter.pyi 
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
def update_config_args(
    self,
    repository: Optional[str] = None,
    name: Optional[str] = None,
    version: Optional[str] = None,
    sample: Optional[bool] = None,
    sample_size: Optional[int] = None,
    feature_map: Optional[FeatureMap] = None,
    targets: Optional[List[str]] = None,
    alert_config: Optional[SpcAlertConfig] = None,
) -> None:
    """Inplace operation that updates config args

    Args:
        repository:
            Model repository
        name:
            Model name
        version:
            Model version
        sample:
            Whether to sample or not
        sample_size:
            Sample size
        feature_map:
            Feature map
        targets:
            List of features that are targets in your dataset.
            This is typically the name of your dependent variable(s).
            This primarily used for monitoring and UI purposes.
        alert_config:
            Alert configuration
    """

update_feature_map(feature_map)

Update feature map

Source code in scouter/_scouter.pyi 
746
747
def update_feature_map(self, feature_map: FeatureMap) -> None:
    """Update feature map"""