causalexplain.estimators.notears package

Submodules

class LBFGSBScipy(params)

Bases: Optimizer

Wrap L-BFGS-B algorithm, using scipy routines.

Courtesy: Arthur Mensch’s gist https://gist.github.com/arthurmensch/c55ac413868550f89225a0b9212aa4cd

__init__(params)

step(closure)

Performs a single optimization step.

Parameters:

closure (callable) – A closure that reevaluates the model and returns the loss.

main()

notears_linear(X, lambda1, loss_type, max_iter=100, h_tol=1e-08, rho_max=1e+16, w_threshold=0.3)

Solve NOTEARS for linear models with an augmented Lagrangian.

class LocallyConnected(num_linear, input_features, output_features, bias=True)

Bases: Module

Local linear layer, i.e. Conv1dLocal() with filter size 1.

Parameters:

• num_linear – num of local linear layers, i.e.

• in_features – m1

• out_features – m2

• bias – whether to include bias or not

Shape:

• Input: [n, d, m1]

• Output: [n, d, m2]

weight

[d, m1, m2]

bias

[d, m2]

__init__(num_linear, input_features, output_features, bias=True)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

reset_parameters()

forward(input)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

extra_repr()

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

main()

least_squares_loss(W, data, cov, d, n)

least_squares_loss_grad(W, data, cov, d, n)

least_squares_loss_cov(W, data, cov, d, n)

least_squares_loss_cov_grad(W, data, cov, d, n)

run(variant, data, loss, loss_grad, **kwargs)

notears_standard(data, loss, loss_grad, c=0.25, r=10.0, e=1e-08, rnd_W_init=False, output_all_progress=False, verbose=False, max_iter=None)

Runs NOTEARS algorithm.

Parameters:

• data (np.array) – n x d data matrix with n samples, d variables

• c (float) – minimum rate of progress, c in (0,1)

• r (float) – penalty growth rate, r > 1

• e (float) – optimation accuracy, e > 0 (acyclicity stopping criteria)

• loss (function) – loss function

• loss_grad (function) – gradient of the loss function

• rnd_W_init (bool) – initialize W to std. normal random matrix, rather than zero matrix

• output_all_progress (bool) – return all intermediate values of W, rather than

• value (just the final)

• verbose (bool) – print optimization information

Returns:

{ ‘h’: acyclicity of output,

’loss’: loss of output, ‘W’: resulting optimized adjacency matrix}

Return type:

dict

class NotearsMLP(dims, bias=True)

Bases: Module

__init__(dims, bias=True)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

h_func()

Constrain 2-norm-squared of fc1 weights along m1 dim to be a DAG

l2_reg()

Take 2-norm-squared of all parameters

fc1_l1_reg()

Take l1 norm of fc1 weight

fc1_to_adj()

Get W from fc1 weights, take 2-norm over m1 dim

class NotearsSobolev(d, k)

Bases: Module

__init__(d, k)

d: num variables k: num expansion of each variable

sobolev_basis(x)

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

h_func()

l2_reg()

fc1_l1_reg()

fc1_to_adj()

squared_loss(output, target)

dual_ascent_step(model, X, lambda1, lambda2, rho, alpha, h, rho_max)

Perform one step of dual ascent in augmented Lagrangian.

notears_nonlinear(model, X, lambda1=0.0, lambda2=0.0, max_iter=100, h_tol=1e-08, rho_max=1e+16, w_threshold=0.3)

main()

NOTEARS

3. Original code from xunzheng/notears

class NOTEARS(name, loss=<function least_squares_loss>, loss_grad=<function least_squares_loss_grad>, c=0.25, r=10.0, e=1e-08, rnd_W_init=False, verbose=False)

Bases: object

__init__(name, loss=<function least_squares_loss>, loss_grad=<function least_squares_loss_grad>, c=0.25, r=10.0, e=1e-08, rnd_W_init=False, verbose=False)

notears_standard(data, return_all_progress=False, max_iter=None)

Runs NOTEARS algorithm.

Parameters:

• data (np.array) – n x d data matrix with n samples, d variables

• c (float) – minimum rate of progress, c in (0,1)

• r (float) – penalty growth rate, r > 1

• e (float) – optimation accuracy, e > 0 (acyclicity stopping criteria)

• loss (function) – loss function

• loss_grad (function) – gradient of the loss function

• rnd_W_init (bool) – initialize W to std. normal random matrix, rather than zero matrix

• output_all_progress (bool) – return all intermediate values of W, rather than

• value (just the final)

Returns:

{ ‘h’: acyclicity of output,

’loss’: loss of output, ‘W’: resulting optimized adjacency matrix}

Return type:

dict

fit(X, **kwargs)

predict(ref_graph=None, threshold=0.1)

fit_predict(train, test, ref_graph=None, threshold=0.1, **kwargs)

main(dataset_name, input_path='/Users/renero/phd/data/', output_path='/Users/renero/phd/output/', save=False)

class TraceExpm(*args, **kwargs)

Bases: Function

static forward(ctx, input)

Compute the trace of the matrix exponential.

static backward(ctx, grad_output)

Compute gradients for the trace-expm operation.

main()

set_random_seed(seed)

is_dag(W)

simulate_dag(d, s0, graph_type)

Simulate random DAG with some expected number of edges.

Parameters:

• d (int) – num of nodes

• s0 (int) – expected num of edges

• graph_type (str) – ER, SF, BP

Returns:

[d, d] binary adj matrix of DAG

Return type:

B (np.ndarray)

simulate_parameter(B, w_ranges=((-2.0, -0.5), (0.5, 2.0)))

Simulate SEM parameters for a DAG.

Parameters:

• B (np.ndarray) – [d, d] binary adj matrix of DAG

• w_ranges (tuple) – disjoint weight ranges

Returns:

[d, d] weighted adj matrix of DAG

Return type:

W (np.ndarray)

simulate_linear_sem(W, n, sem_type, noise_scale=None)

Simulate samples from linear SEM with specified type of noise.

For uniform, noise z ~ uniform(-a, a), where a = noise_scale.

Parameters:

• W (np.ndarray) – [d, d] weighted adj matrix of DAG

• n (int) – num of samples, n=inf mimics population risk

• sem_type (str) – gauss, exp, gumbel, uniform, logistic, poisson

• noise_scale (np.ndarray) – scale parameter of additive noise, default all ones

Returns:

[n, d] sample matrix, [d, d] if n=inf

Return type:

X (np.ndarray)

simulate_nonlinear_sem(B, n, sem_type, noise_scale=None)

Simulate samples from nonlinear SEM.

Parameters:

• B (np.ndarray) – [d, d] binary adj matrix of DAG

• n (int) – num of samples

• sem_type (str) – mlp, mim, gp, gp-add

• noise_scale (np.ndarray) – scale parameter of additive noise, default all ones

Returns:

[n, d] sample matrix

Return type:

X (np.ndarray)

count_accuracy(B_true, B_est)

Compute various accuracy metrics for B_est.

true positive = predicted association exists in condition in correct direction reverse = predicted association exists in condition in opposite direction false positive = predicted association does not exist in condition

Parameters:

• B_true (np.ndarray) – [d, d] ground truth graph, {0, 1}

• B_est (np.ndarray) – [d, d] estimate, {0, 1, -1}, -1 is undirected edge in CPDAG

Returns:

(reverse + false positive) / prediction positive tpr: (true positive) / condition positive fpr: (reverse + false positive) / condition negative shd: undirected extra + undirected missing + reverse nnz: prediction positive

Return type:

fdr

threshold_output(W, desired_edges=None, verbose=False)

generate_random_dag(num_nodes, num_edges, probabilistic=False, edge_coefficient_range=[0.5, 2.0])

simulate_from_dag_lg(tam, n_sample, mean=0, variance=1)

compare_graphs_undirected(true_graph, estimated_graph)

compare_graphs_precision(x)

compare_graphs_recall(x)

compare_graphs_specificity(x)

Module contents