Contents

This Page

  1. Docs
  2. actableai.causal.discover.algorithms package

actableai.causal.discover.algorithms package

Submodules

actableai.causal.discover.algorithms.deci module

class actableai.causal.discover.algorithms.deci.DeciRunner(p: actableai.causal.discover.algorithms.payloads.DeciPayload, progress_callback: Optional[Callable[[float], None]] = None)

Bases: actableai.causal.discover.algorithms.commons.base_runner.CausalDiscoveryRunner

do_causal_discovery() → Dict[str, list]
name = 'DECI'

actableai.causal.discover.algorithms.direct_lingam module

class actableai.causal.discover.algorithms.direct_lingam.DirectLiNGAMRunner(p: actableai.causal.discover.algorithms.payloads.DirectLiNGAMPayload, progress_callback: Optional[Callable[[float], None]] = None)

Bases: actableai.causal.discover.algorithms.commons.base_runner.CausalDiscoveryRunner

do_causal_discovery() → Dict[str, list]
name = 'DirectLiNGAM'

actableai.causal.discover.algorithms.notears module

class actableai.causal.discover.algorithms.notears.NotearsRunner(p: actableai.causal.discover.algorithms.payloads.NotearsPayload, progress_callback: Optional[Callable[[float], None]] = None)

Bases: actableai.causal.discover.algorithms.commons.base_runner.CausalDiscoveryRunner

do_causal_discovery() → Dict[str, list]
name = 'Notears'

actableai.causal.discover.algorithms.payloads module

class actableai.causal.discover.algorithms.payloads.ATEDetails(*, reference: Optional[Union[float, str]] = None, intervention: Optional[Union[float, str]] = None, nature: Optional[actableai.causal.discover.algorithms.payloads.CausalVariableNature] = None)

Bases: pydantic.main.BaseModel

intervention: Optional[Union[float, str]]
nature: Optional[actableai.causal.discover.algorithms.payloads.CausalVariableNature]
reference: Optional[Union[float, str]]
class actableai.causal.discover.algorithms.payloads.CausalDiscoveryPayload(*, dataset: actableai.causal.discover.algorithms.payloads.Dataset, normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions = NormalizationOptions(with_mean=True, with_std=True), constraints: actableai.causal.discover.algorithms.payloads.Constraints, causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable] = [])

Bases: pydantic.main.BaseModel

class Config

Bases: object

arbitrary_types_allowed = True
causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable]
constraints: actableai.causal.discover.algorithms.payloads.Constraints
dataset: actableai.causal.discover.algorithms.payloads.Dataset
normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions
classmethod set_causal_variables(values: Dict[str, Any]) → Dict[str, Any]
class actableai.causal.discover.algorithms.payloads.CausalVariable(*, name: str, nature: Optional[actableai.causal.discover.algorithms.payloads.CausalVariableNature] = None)

Bases: pydantic.main.BaseModel

classmethod from_dataset(column: str, dataset: actableai.causal.discover.algorithms.payloads.Dataset) → actableai.causal.discover.algorithms.payloads.CausalVariable
name: str
nature: Optional[actableai.causal.discover.algorithms.payloads.CausalVariableNature]
class actableai.causal.discover.algorithms.payloads.CausalVariableNature(value)

Bases: str, enum.Enum

An enumeration.

Binary = 'Binary'
CategoricalNominal = 'Categorical Nominal'
CategoricalOrdinal = 'Categorical Ordinal'
Continuous = 'Continuous'
Discrete = 'Discrete'
Excluded = 'Excluded'
class actableai.causal.discover.algorithms.payloads.Constraints(*, causes: List[str], effects: List[str], forbiddenRelationships: List[Tuple[str, str]], potentialRelationships: Optional[List[Tuple[str, str]]] = None)

Bases: pydantic.main.BaseModel

causes: List[str]
effects: List[str]
forbiddenRelationships: List[Tuple[str, str]]
potentialRelationships: Optional[List[Tuple[str, str]]]
class actableai.causal.discover.algorithms.payloads.Dataset(*, data: Dict[str, List[Any]])

Bases: pydantic.main.BaseModel

data: Dict[str, List[Any]]
class actableai.causal.discover.algorithms.payloads.DeciAteOptions(*, Ngraphs: Optional[int] = 1, Nsamples_per_graph: Optional[int] = 5000, most_likely_graph: Optional[int] = True, ate_details_by_name: Dict[str, actableai.causal.discover.algorithms.payloads.ATEDetails] = {})

Bases: pydantic.main.BaseModel

Ngraphs: Optional[int]
Nsamples_per_graph: Optional[int]
ate_details_by_name: Dict[str, actableai.causal.discover.algorithms.payloads.ATEDetails]
most_likely_graph: Optional[int]
class actableai.causal.discover.algorithms.payloads.DeciModelOptions(*, base_distribution_type: Literal['gaussian', 'spline'] = 'spline', spline_bins: int = 8, imputation: bool = False, lambda_dag: float = 100.0, lambda_sparse: float = 5.0, tau_gumbel: float = 1.0, var_dist_A_mode: Literal['simple', 'enco', 'true', 'three'] = 'three', imputer_layer_sizes: Optional[List[int]] = None, mode_adjacency: Literal['upper', 'lower', 'learn'] = 'learn', norm_layers: bool = True, res_connection: bool = True, encoder_layer_sizes: Optional[List[int]] = [32, 32], decoder_layer_sizes: Optional[List[int]] = [32, 32], cate_rff_n_features: int = 3000, cate_rff_lengthscale: Union[int, float, List[float], Tuple[float, float]] = 1)

Bases: pydantic.main.BaseModel

base_distribution_type: Literal['gaussian', 'spline']
cate_rff_lengthscale: Union[int, float, List[float], Tuple[float, float]]
cate_rff_n_features: int
decoder_layer_sizes: Optional[List[int]]
encoder_layer_sizes: Optional[List[int]]
imputation: bool
imputer_layer_sizes: Optional[List[int]]
lambda_dag: float
lambda_sparse: float
mode_adjacency: Literal['upper', 'lower', 'learn']
norm_layers: bool
res_connection: bool
spline_bins: int
tau_gumbel: float
var_dist_A_mode: Literal['simple', 'enco', 'true', 'three']
class actableai.causal.discover.algorithms.payloads.DeciPayload(*, dataset: actableai.causal.discover.algorithms.payloads.Dataset, normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions = NormalizationOptions(with_mean=True, with_std=True), constraints: actableai.causal.discover.algorithms.payloads.Constraints, causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable] = [], model_options: actableai.causal.discover.algorithms.payloads.DeciModelOptions = DeciModelOptions(base_distribution_type='spline', spline_bins=8, imputation=False, lambda_dag=100.0, lambda_sparse=5.0, tau_gumbel=1.0, var_dist_A_mode='three', imputer_layer_sizes=None, mode_adjacency='learn', norm_layers=True, res_connection=True, encoder_layer_sizes=[32, 32], decoder_layer_sizes=[32, 32], cate_rff_n_features=3000, cate_rff_lengthscale=1), training_options: actableai.causal.discover.algorithms.payloads.DeciTrainingOptions = DeciTrainingOptions(learning_rate=0.03, batch_size=512, standardize_data_mean=False, standardize_data_std=False, rho=10.0, safety_rho=10000000000000.0, alpha=0.0, safety_alpha=10000000000000.0, tol_dag=0.001, progress_rate=0.25, max_steps_auglag=20, max_auglag_inner_epochs=1000, max_p_train_dropout=0.25, reconstruction_loss_factor=1.0, anneal_entropy='noanneal'), ate_options: actableai.causal.discover.algorithms.payloads.DeciAteOptions = DeciAteOptions(Ngraphs=1, Nsamples_per_graph=5000, most_likely_graph=True, ate_details_by_name={}), model_save_dir: str = None)

Bases: actableai.causal.discover.algorithms.payloads.CausalDiscoveryPayload

ate_options: actableai.causal.discover.algorithms.payloads.DeciAteOptions
model_options: actableai.causal.discover.algorithms.payloads.DeciModelOptions
model_save_dir: str
training_options: actableai.causal.discover.algorithms.payloads.DeciTrainingOptions
class actableai.causal.discover.algorithms.payloads.DeciTrainingOptions(*, learning_rate: float = 0.03, batch_size: int = 512, standardize_data_mean: bool = False, standardize_data_std: bool = False, rho: float = 10.0, safety_rho: float = 10000000000000.0, alpha: float = 0.0, safety_alpha: float = 10000000000000.0, tol_dag: float = 0.001, progress_rate: float = 0.25, max_steps_auglag: int = 20, max_auglag_inner_epochs: int = 1000, max_p_train_dropout: float = 0.25, reconstruction_loss_factor: float = 1.0, anneal_entropy: Literal['linear', 'noanneal'] = 'noanneal')

Bases: pydantic.main.BaseModel

alpha: float
anneal_entropy: Literal['linear', 'noanneal']
batch_size: int
learning_rate: float
max_auglag_inner_epochs: int
max_p_train_dropout: float
max_steps_auglag: int
progress_rate: float
reconstruction_loss_factor: float
rho: float
safety_alpha: float
safety_rho: float
standardize_data_mean: bool
standardize_data_std: bool
tol_dag: float
class actableai.causal.discover.algorithms.payloads.DirectLiNGAMPayload(*, dataset: actableai.causal.discover.algorithms.payloads.Dataset, normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions = NormalizationOptions(with_mean=True, with_std=True), constraints: actableai.causal.discover.algorithms.payloads.Constraints, causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable] = [])

Bases: actableai.causal.discover.algorithms.payloads.CausalDiscoveryPayload

causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable]
constraints: actableai.causal.discover.algorithms.payloads.Constraints
dataset: actableai.causal.discover.algorithms.payloads.Dataset
normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions
class actableai.causal.discover.algorithms.payloads.NormalizationOptions(*, with_mean: bool = True, with_std: bool = True)

Bases: pydantic.main.BaseModel

with_mean: bool
with_std: bool
class actableai.causal.discover.algorithms.payloads.NotearsPayload(*, dataset: actableai.causal.discover.algorithms.payloads.Dataset, normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions = NormalizationOptions(with_mean=True, with_std=True), constraints: actableai.causal.discover.algorithms.payloads.Constraints, causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable] = [], max_iter: int = 100)

Bases: actableai.causal.discover.algorithms.payloads.CausalDiscoveryPayload

max_iter: int
class actableai.causal.discover.algorithms.payloads.PCPayload(*, dataset: actableai.causal.discover.algorithms.payloads.Dataset, normalization: actableai.causal.discover.algorithms.payloads.NormalizationOptions = NormalizationOptions(with_mean=True, with_std=True), constraints: actableai.causal.discover.algorithms.payloads.Constraints, causal_variables: List[actableai.causal.discover.algorithms.payloads.CausalVariable] = [], variant: Literal['original', 'stable'] = 'original', alpha: float = 0.05, ci_test: Literal['gauss', 'g2', 'chi2'] = 'gauss')

Bases: actableai.causal.discover.algorithms.payloads.CausalDiscoveryPayload

alpha: float
ci_test: Literal['gauss', 'g2', 'chi2']
variant: Literal['original', 'stable']

actableai.causal.discover.algorithms.pc module

class actableai.causal.discover.algorithms.pc.PCRunner(p: actableai.causal.discover.algorithms.payloads.PCPayload, progress_callback: Optional[Callable[[float], None]] = None)

Bases: actableai.causal.discover.algorithms.commons.base_runner.CausalDiscoveryRunner

do_causal_discovery() → Dict[str, list]
name = 'PC'

actableai.causal.discover.algorithms.runners module

Module contents

© Copyright 2022, ActableAI Team. Created using Sphinx.