def train(model_name, X, true_dag, model_params, topology_matrix=None, plot=True): """run algorithm of castle Parameters ---------- model_name: str algorithm name X: pd.DataFrame train data true_dag: array true directed acyclic graph model_params: dict Parameters from configuration file topology_matrix: array, default None topology graph matrix plot: boolean, default None whether show graph. Returns ------- model: castle.algorithm model of castle.algorithm pre_dag: array discovered causal matrix """ # Instantiation algorithm and learn dag if model_name == 'TTPM': model = INLINE_ALGORITHMS[model_name.upper()](topology_matrix, **model_params) model.learn(X) elif model_name == 'NOTEARSLOWRANK': rank = model_params.get('rank') del model_params['rank'] model = NotearsLowRank(**model_params) model.learn(X, rank=rank) else: try: model = INLINE_ALGORITHMS[model_name.upper()](**model_params) model.learn(data=X) except ValueError: raise ValueError('Invalid algorithm name: {}.'.format(model_name)) pre_dag = model.causal_matrix if plot: if true_dag is not None: GraphDAG(pre_dag, true_dag, show=plot) m = MetricsDAG(pre_dag, true_dag) print(m.metrics) else: GraphDAG(pre_dag, show=plot) return model, pre_dag
def castle_experiment(model, x, y=None, show_graph=False, **kwargs): model.learn(x, **kwargs) if y is not None: metrics = MetricsDAG(model.causal_matrix, y).metrics else: metrics = None if show_graph: GraphDAG(model.causal_matrix, y) return metrics
`networkx` package, then like the following import method. Warnings: This script is used only for demonstration and cannot be directly imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, IIDSimulation from castle.algorithms import DirectLiNGAM ####################################### # DirectLiNGAM used simulate data ####################################### # simulate data for DirectLiNGAM weighted_random_dag = DAG.erdos_renyi(n_nodes=10, n_edges=20, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=2000, method='linear', sem_type='gauss') true_dag, X = dataset.B, dataset.X # DirectLiNGAM learn g = DirectLiNGAM() g.learn(X) # plot est_dag and true_dag GraphDAG(g.causal_matrix, true_dag) # calculate accuracy met = MetricsDAG(g.causal_matrix, true_dag) print(met.metrics)
imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, IIDSimulation from castle.algorithms import GraN_DAG, Parameters # load data weighted_random_dag = DAG.erdos_renyi(n_nodes=10, n_edges=20, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=2000, method='nonlinear', sem_type='mlp') dag, x = dataset.B, dataset.X # Initialize parameters for gran_dag parameters = Parameters(input_dim=x.shape[1]) # Instantiation algorithm gnd = GraN_DAG(params=parameters) gnd.learn(data=x, target=dag) # plot predict_dag and true_dag GraphDAG(gnd.causal_matrix, dag, 'result') mm = MetricsDAG(gnd.causal_matrix, dag) print(mm.metrics)
how to use TTPM algorithm in `castle` package for causal inference. Warnings: This script is used only for demonstration and cannot be directly imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, Topology, THPSimulation from castle.algorithms import TTPM # Data Simulation for TTPM true_causal_matrix = DAG.erdos_renyi(n_nodes=10, n_edges=10) topology_matrix = Topology.erdos_renyi(n_nodes=20, n_edges=20) simulator = THPSimulation(true_causal_matrix, topology_matrix, mu_range=(0.00005, 0.0001), alpha_range=(0.005, 0.007)) X = simulator.simulate(T=3600 * 24, max_hop=2) # TTPM modeling ttpm = TTPM(topology_matrix, max_hop=2) ttpm.learn(X) print(ttpm.causal_matrix) # plot est_dag and true_dag GraphDAG(ttpm.causal_matrix, true_causal_matrix) # calculate accuracy ret_metrix = MetricsDAG(ttpm.causal_matrix, true_causal_matrix) print(ret_metrix.metrics)
imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, IIDSimulation from castle.algorithms import PC # simulation for pc weighted_random_dag = DAG.erdos_renyi(n_nodes=10, n_edges=20, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=2000, method='linear', sem_type='gauss') true_dag, X = dataset.B, dataset.X # PC learn pc = PC() pc.learn(X) # plot predict_dag and true_dag GraphDAG(pc.causal_matrix) GraphDAG(pc.causal_matrix, true_dag, 'result_pc') # calculate accuracy met = MetricsDAG(pc.causal_matrix, true_dag) print(met.metrics)
If you want to plot causal graph, please make sure you have already install `networkx` package, then like the following import method. Warnings: This script is used only for demonstration and cannot be directly imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, IIDSimulation from castle.algorithms import ANMNonlinear weighted_random_dag = DAG.erdos_renyi(n_nodes=6, n_edges=10, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=1000, method='nonlinear', sem_type='gp-add') true_dag, X = dataset.B, dataset.X anm = ANMNonlinear(alpha=0.05) anm.learn(data=X) # plot predict_dag and true_dag GraphDAG(anm.causal_matrix, true_dag) mm = MetricsDAG(anm.causal_matrix, true_dag) print(mm.metrics)
how to use TTPM algorithm in `castle` package for causal inference. Warnings: This script is used only for demonstration and cannot be directly imported. """ from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.datasets import DAG, Topology, THPSimulation from castle.algorithms import TTPM # Data Simulation for TTPM true_causal_matrix = DAG.erdos_renyi(n_nodes=10, n_edges=10) topology_matrix = Topology.erdos_renyi(n_nodes=20, n_edges=20) simulator = THPSimulation(true_causal_matrix, topology_matrix, mu_range=(0.00005, 0.0001), alpha_range=(0.005, 0.007)) X = simulator.simulate(T=3600 * 24, max_hop=2) # TTPM modeling ttpm = TTPM(topology_matrix, max_hop=2) ttpm.learn(X) print(ttpm.causal_matrix) # plot est_dag and true_dag GraphDAG(ttpm.causal_matrix.values, true_causal_matrix) # calculate accuracy ret_metrix = MetricsDAG(ttpm.causal_matrix.values, true_causal_matrix) print(ret_metrix.metrics)
# distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from castle.datasets import DAG, IIDSimulation from castle.common import GraphDAG from castle.metrics import MetricsDAG from castle.algorithms.ges.ges import GES for d in [6, 8, 10, 15, 20]: edges = d * 2 weighted_random_dag = DAG.erdos_renyi(n_nodes=d, n_edges=edges, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=1000, method='nonlinear', sem_type='gp-add') true_dag, X = dataset.B, dataset.X algo = GES(criterion='bic', method='scatter') algo.learn(X) # plot predict_dag and true_dag GraphDAG(algo.causal_matrix, true_dag) m1 = MetricsDAG(algo.causal_matrix, true_dag) print(m1.metrics) break
from castle.metrics import MetricsDAG from castle.datasets import DAG, IIDSimulation from castle.algorithms import GraNDAG # load data weighted_random_dag = DAG.erdos_renyi(n_nodes=10, n_edges=20, weight_range=(0.5, 2.0), seed=1) dataset = IIDSimulation(W=weighted_random_dag, n=2000, method='nonlinear', sem_type='mlp') dag, x = dataset.B, dataset.X # Instantiation algorithm d = { 'model_name': 'NonLinGauss', 'nonlinear': 'leaky-relu', 'optimizer': 'sgd', 'norm_prod': 'paths', 'device_type': 'gpu' } gnd = GraNDAG(input_dim=x.shape[1], ) gnd.learn(data=x) # plot predict_dag and true_dag GraphDAG(gnd.causal_matrix, dag) mm = MetricsDAG(gnd.causal_matrix, dag) print(mm.metrics)
from castle.algorithms import RL g = RL(**params_config['model_params']) g.learn(data=X, dag=true_dag) elif args.model_name == 'ttpm': from castle.algorithms import TTPM g = TTPM(topology_matrix, **params_config['model_params']) g.learn(X) else: raise ValueError('Invalid algorithm name: {}.'.format(args.model_name)) # plot and evaluate predict_dag and true_dag if true_dag is not None: if args.model_name == 'ttpm': GraphDAG(g.causal_matrix.values, true_dag) m = MetricsDAG(g.causal_matrix.values, true_dag) print(m.metrics) else: GraphDAG(g.causal_matrix, true_dag) m = MetricsDAG(g.causal_matrix, true_dag) print(m.metrics) else: if args.model_name == 'ttpm': GraphDAG(g.causal_matrix.values) else: GraphDAG(g.causal_matrix)